@atproto/api 0.12.25 → 0.13.0-rc.0

package/dist/agent.js

@@ -1,452 +1,1130 @@
 "use strict";
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Agent_prefsLock;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AtpAgent = void 0;
-const xrpc_1 = require("@atproto/xrpc");
-const xrpc_2 = require("@atproto/xrpc");
+exports.Agent = void 0;
 const common_web_1 = require("@atproto/common-web");
-const client_1 = require("./client");
-const const_1 = require("./const");
-const REFRESH_SESSION = 'com.atproto.server.refreshSession';
+const syntax_1 = require("@atproto/syntax");
+const await_lock_1 = __importDefault(require("await-lock"));
+const atp_client_1 = require("./atp-client");
+const index_1 = require("./client/index");
+const moderation_1 = require("./moderation");
+const labels_1 = require("./moderation/const/labels");
+const util_1 = require("./util");
+const FEED_VIEW_PREF_DEFAULTS = {
+    hideReplies: false,
+    hideRepliesByUnfollowed: true,
+    hideRepliesByLikeCount: 0,
+    hideReposts: false,
+    hideQuotePosts: false,
+};
+const THREAD_VIEW_PREF_DEFAULTS = {
+    sort: 'oldest',
+    prioritizeFollowedUsers: true,
+};
 /**
- * An ATP "Agent"
- * Manages session token lifecycles and provides convenience methods.
+ * {@link Agent} is an abstract class that extends {@link AtpClient} with
+ * (abstract) session based utilities and bsky-specific methods.
  */
-class AtpAgent {
-    get com() {
-        return this.api.com;
-    }
-    /**
-     * Configures the API globally.
-     */
-    static configure(opts) {
-        if (opts.fetch) {
-            AtpAgent.fetch = opts.fetch;
-        }
-        if (opts.appLabelers) {
-            AtpAgent.appLabelers = opts.appLabelers;
-        }
-    }
-    constructor(opts) {
-        Object.defineProperty(this, "service", {
+class Agent extends atp_client_1.AtpClient {
+    constructor() {
+        super(...arguments);
+        //#endregion
+        //#region "app.bsky" lexicon short hand methods
+        Object.defineProperty(this, "getTimeline", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.feed.getTimeline(params, opts)
         });
-        Object.defineProperty(this, "api", {
+        Object.defineProperty(this, "getAuthorFeed", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.feed.getAuthorFeed(params, opts)
         });
-        Object.defineProperty(this, "session", {
+        Object.defineProperty(this, "getActorLikes", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.feed.getActorLikes(params, opts)
         });
-        Object.defineProperty(this, "labelersHeader", {
+        Object.defineProperty(this, "getPostThread", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: []
+            value: (params, opts) => this.app.bsky.feed.getPostThread(params, opts)
         });
-        Object.defineProperty(this, "proxyHeader", {
+        Object.defineProperty(this, "getPost", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params) => this.app.bsky.feed.post.get(params)
         });
-        Object.defineProperty(this, "pdsUrl", {
+        Object.defineProperty(this, "getPosts", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
-        }); // The PDS URL, driven by the did doc. May be undefined.
-        Object.defineProperty(this, "_baseClient", {
+            value: (params, opts) => this.app.bsky.feed.getPosts(params, opts)
+        });
+        Object.defineProperty(this, "getLikes", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.feed.getLikes(params, opts)
         });
-        Object.defineProperty(this, "_persistSession", {
+        Object.defineProperty(this, "getRepostedBy", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.feed.getRepostedBy(params, opts)
         });
-        Object.defineProperty(this, "_refreshSessionPromise", {
+        Object.defineProperty(this, "getFollows", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: (params, opts) => this.app.bsky.graph.getFollows(params, opts)
         });
-        /**
-         * Upload a binary blob to the server
-         */
-        Object.defineProperty(this, "uploadBlob", {
+        Object.defineProperty(this, "getFollowers", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (data, opts) => this.api.com.atproto.repo.uploadBlob(data, opts)
+            value: (params, opts) => this.app.bsky.graph.getFollowers(params, opts)
         });
-        /**
-         * Resolve a handle to a DID
-         */
-        Object.defineProperty(this, "resolveHandle", {
+        Object.defineProperty(this, "getProfile", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (params, opts) => this.api.com.atproto.identity.resolveHandle(params, opts)
+            value: (params, opts) => this.app.bsky.actor.getProfile(params, opts)
         });
-        /**
-         * Change the user's handle
-         */
-        Object.defineProperty(this, "updateHandle", {
+        Object.defineProperty(this, "getProfiles", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (data, opts) => this.api.com.atproto.identity.updateHandle(data, opts)
+            value: (params, opts) => this.app.bsky.actor.getProfiles(params, opts)
         });
-        /**
-         * Create a moderation report
-         */
-        Object.defineProperty(this, "createModerationReport", {
+        Object.defineProperty(this, "getSuggestions", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: (data, opts) => this.api.com.atproto.moderation.createReport(data, opts)
-        });
-        this.service =
-            opts.service instanceof URL ? opts.service : new URL(opts.service);
-        this._persistSession = opts.persistSession;
-        // create an ATP client instance for this agent
-        this._baseClient = new client_1.AtpBaseClient();
-        this._baseClient.xrpc.fetch = this._fetch.bind(this); // patch its fetch implementation
-        this.api = this._baseClient.service(opts.service);
-    }
-    clone() {
-        const inst = new AtpAgent({
-            service: this.service,
-        });
-        this.copyInto(inst);
-        return inst;
-    }
-    copyInto(inst) {
-        inst.session = this.session;
-        inst.labelersHeader = this.labelersHeader;
-        inst.proxyHeader = this.proxyHeader;
-        inst.pdsUrl = this.pdsUrl;
-        inst.api.xrpc.uri = this.pdsUrl || this.service;
-    }
-    withProxy(serviceType, did) {
-        const inst = this.clone();
-        inst.configureProxyHeader(serviceType, did);
-        return inst;
+            value: (params, opts) => this.app.bsky.actor.getSuggestions(params, opts)
+        });
+        Object.defineProperty(this, "searchActors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.app.bsky.actor.searchActors(params, opts)
+        });
+        Object.defineProperty(this, "searchActorsTypeahead", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.app.bsky.actor.searchActorsTypeahead(params, opts)
+        });
+        Object.defineProperty(this, "listNotifications", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.app.bsky.notification.listNotifications(params, opts)
+        });
+        Object.defineProperty(this, "countUnreadNotifications", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.app.bsky.notification.getUnreadCount(params, opts)
+        });
+        Object.defineProperty(this, "getLabelers", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (params, opts) => this.app.bsky.labeler.getServices(params, opts)
+        });
+        //- Private methods
+        _Agent_prefsLock.set(this, new await_lock_1.default()
+        /**
+         * This function updates the preferences of a user and allows for a callback function to be executed
+         * before the update.
+         * @param cb - cb is a callback function that takes in a single parameter of type
+         * AppBskyActorDefs.Preferences and returns either a boolean or void. This callback function is used to
+         * update the preferences of the user. The function is called with the current preferences as an
+         * argument and if the callback returns false, the preferences are not updated.
+         */
+        );
+        //#endregion
     }
-    /**
-     * Is there any active session?
-     */
-    get hasSession() {
-        return !!this.session;
+    /** @deprecated use "this" instead */
+    get api() {
+        return this;
     }
     /**
-     * Sets the "Persist Session" method which can be used to store access tokens
-     * as they change.
+     * Get the authenticated user's DID, or throw an error if not authenticated.
      */
-    setPersistSessionHandler(handler) {
-        this._persistSession = handler;
+    get accountDid() {
+        this.assertAuthenticated();
+        return this.did;
     }
     /**
-     * Configures the moderation services to be applied on requests.
-     * NOTE: this is called automatically by getPreferences() and the relevant moderation config
-     * methods in BskyAgent instances.
+     * Assert that the user is authenticated.
      */
-    configureLabelersHeader(labelerDids) {
-        this.labelersHeader = labelerDids;
+    assertAuthenticated() {
+        if (!this.did)
+            throw new Error('Not logged in');
     }
-    /**
-     * Configures the atproto-proxy header to be applied on requests
-     */
-    configureProxyHeader(serviceType, did) {
-        if (did.startsWith('did:')) {
-            this.proxyHeader = `${did}#${serviceType}`;
+    async getLabelDefinitions(prefs) {
+        // collect the labeler dids
+        const dids = [...this.appLabelers];
+        if (isBskyPrefs(prefs)) {
+            dids.push(...prefs.moderationPrefs.labelers.map((l) => l.did));
         }
-    }
-    /**
-     * Create a new account and hydrate its session in this agent.
-     */
-    async createAccount(opts) {
-        try {
-            const res = await this.api.com.atproto.server.createAccount(opts);
-            this.session = {
-                accessJwt: res.data.accessJwt,
-                refreshJwt: res.data.refreshJwt,
-                handle: res.data.handle,
-                did: res.data.did,
-                email: opts.email,
-                emailConfirmed: false,
-                emailAuthFactor: false,
-                active: true,
-            };
-            this._updateApiEndpoint(res.data.didDoc);
-            return res;
+        else if (isModPrefs(prefs)) {
+            dids.push(...prefs.labelers.map((l) => l.did));
         }
-        catch (e) {
-            this.session = undefined;
-            throw e;
+        else {
+            dids.push(...prefs);
         }
-        finally {
-            if (this.session) {
-                this._persistSession?.('create', this.session);
+        // fetch their definitions
+        const labelers = await this.getLabelers({
+            dids,
+            detailed: true,
+        });
+        // assemble a map of labeler dids to the interpretted label value definitions
+        const labelDefs = {};
+        if (labelers.data) {
+            for (const labeler of labelers.data
+                .views) {
+                labelDefs[labeler.creator.did] = (0, moderation_1.interpretLabelValueDefinitions)(labeler);
             }
-            else {
-                this._persistSession?.('create-failed', undefined);
+        }
+        return labelDefs;
+    }
+    async post(record) {
+        record.createdAt || (record.createdAt = new Date().toISOString());
+        return this.app.bsky.feed.post.create({ repo: this.accountDid }, record);
+    }
+    async deletePost(postUri) {
+        this.assertAuthenticated();
+        const postUrip = new syntax_1.AtUri(postUri);
+        return this.app.bsky.feed.post.delete({
+            repo: postUrip.hostname,
+            rkey: postUrip.rkey,
+        });
+    }
+    async like(uri, cid) {
+        return this.app.bsky.feed.like.create({ repo: this.accountDid }, {
+            subject: { uri, cid },
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteLike(likeUri) {
+        this.assertAuthenticated();
+        const likeUrip = new syntax_1.AtUri(likeUri);
+        return this.app.bsky.feed.like.delete({
+            repo: likeUrip.hostname,
+            rkey: likeUrip.rkey,
+        });
+    }
+    async repost(uri, cid) {
+        return this.app.bsky.feed.repost.create({ repo: this.accountDid }, {
+            subject: { uri, cid },
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteRepost(repostUri) {
+        this.assertAuthenticated();
+        const repostUrip = new syntax_1.AtUri(repostUri);
+        return this.app.bsky.feed.repost.delete({
+            repo: repostUrip.hostname,
+            rkey: repostUrip.rkey,
+        });
+    }
+    async follow(subjectDid) {
+        return this.app.bsky.graph.follow.create({ repo: this.accountDid }, {
+            subject: subjectDid,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async deleteFollow(followUri) {
+        this.assertAuthenticated();
+        const followUrip = new syntax_1.AtUri(followUri);
+        return this.app.bsky.graph.follow.delete({
+            repo: followUrip.hostname,
+            rkey: followUrip.rkey,
+        });
+    }
+    async upsertProfile(updateFn) {
+        const repo = this.accountDid;
+        let retriesRemaining = 5;
+        while (retriesRemaining >= 0) {
+            // fetch existing
+            const existing = await this.com.atproto.repo
+                .getRecord({
+                repo,
+                collection: 'app.bsky.actor.profile',
+                rkey: 'self',
+            })
+                .catch((_) => undefined);
+            // run the update
+            const updated = await updateFn(existing?.data.value);
+            if (updated) {
+                updated.$type = 'app.bsky.actor.profile';
+            }
+            // validate the record
+            const validation = index_1.AppBskyActorProfile.validateRecord(updated);
+            if (!validation.success) {
+                throw validation.error;
+            }
+            try {
+                // attempt the put
+                await this.com.atproto.repo.putRecord({
+                    repo,
+                    collection: 'app.bsky.actor.profile',
+                    rkey: 'self',
+                    record: updated,
+                    swapRecord: existing?.data.cid || null,
+                });
+            }
+            catch (e) {
+                if (retriesRemaining > 0 &&
+                    e instanceof index_1.ComAtprotoRepoPutRecord.InvalidSwapError) {
+                    // try again
+                    retriesRemaining--;
+                    continue;
+                }
+                else {
+                    throw e;
+                }
             }
+            break;
         }
     }
-    /**
-     * Start a new session with this agent.
-     */
-    async login(opts) {
-        try {
-            const res = await this.api.com.atproto.server.createSession({
-                identifier: opts.identifier,
-                password: opts.password,
-                authFactorToken: opts.authFactorToken,
+    async mute(actor) {
+        return this.app.bsky.graph.muteActor({ actor });
+    }
+    async unmute(actor) {
+        return this.app.bsky.graph.unmuteActor({ actor });
+    }
+    async muteModList(uri) {
+        return this.app.bsky.graph.muteActorList({ list: uri });
+    }
+    async unmuteModList(uri) {
+        return this.app.bsky.graph.unmuteActorList({ list: uri });
+    }
+    async blockModList(uri) {
+        return this.app.bsky.graph.listblock.create({ repo: this.accountDid }, {
+            subject: uri,
+            createdAt: new Date().toISOString(),
+        });
+    }
+    async unblockModList(uri) {
+        const repo = this.accountDid;
+        const listInfo = await this.app.bsky.graph.getList({
+            list: uri,
+            limit: 1,
+        });
+        const blocked = listInfo.data.list.viewer?.blocked;
+        if (blocked) {
+            const { rkey } = new syntax_1.AtUri(blocked);
+            return this.app.bsky.graph.listblock.delete({
+                repo,
+                rkey,
             });
-            this.session = {
-                accessJwt: res.data.accessJwt,
-                refreshJwt: res.data.refreshJwt,
-                handle: res.data.handle,
-                did: res.data.did,
-                email: res.data.email,
-                emailConfirmed: res.data.emailConfirmed,
-                emailAuthFactor: res.data.emailAuthFactor,
-                active: res.data.active ?? true,
-                status: res.data.status,
-            };
-            this._updateApiEndpoint(res.data.didDoc);
-            return res;
         }
-        catch (e) {
-            this.session = undefined;
-            throw e;
-        }
-        finally {
-            if (this.session) {
-                this._persistSession?.('create', this.session);
+    }
+    async updateSeenNotifications(seenAt = new Date().toISOString()) {
+        return this.app.bsky.notification.updateSeen({ seenAt });
+    }
+    async getPreferences() {
+        const prefs = {
+            feeds: {
+                saved: undefined,
+                pinned: undefined,
+            },
+            // @ts-ignore populating below
+            savedFeeds: undefined,
+            feedViewPrefs: {
+                home: {
+                    ...FEED_VIEW_PREF_DEFAULTS,
+                },
+            },
+            threadViewPrefs: { ...THREAD_VIEW_PREF_DEFAULTS },
+            moderationPrefs: {
+                adultContentEnabled: false,
+                labels: { ...labels_1.DEFAULT_LABEL_SETTINGS },
+                labelers: this.appLabelers.map((did) => ({
+                    did,
+                    labels: {},
+                })),
+                mutedWords: [],
+                hiddenPosts: [],
+            },
+            birthDate: undefined,
+            interests: {
+                tags: [],
+            },
+            bskyAppState: {
+                queuedNudges: [],
+                activeProgressGuide: undefined,
+            },
+        };
+        const res = await this.app.bsky.actor.getPreferences({});
+        const labelPrefs = [];
+        for (const pref of res.data.preferences) {
+            if (index_1.AppBskyActorDefs.isAdultContentPref(pref) &&
+                index_1.AppBskyActorDefs.validateAdultContentPref(pref).success) {
+                // adult content preferences
+                prefs.moderationPrefs.adultContentEnabled = pref.enabled;
             }
-            else {
-                this._persistSession?.('create-failed', undefined);
+            else if (index_1.AppBskyActorDefs.isContentLabelPref(pref) &&
+                index_1.AppBskyActorDefs.validateContentLabelPref(pref).success) {
+                // content label preference
+                const adjustedPref = adjustLegacyContentLabelPref(pref);
+                labelPrefs.push(adjustedPref);
+            }
+            else if (index_1.AppBskyActorDefs.isLabelersPref(pref) &&
+                index_1.AppBskyActorDefs.validateLabelersPref(pref).success) {
+                // labelers preferences
+                prefs.moderationPrefs.labelers = this.appLabelers
+                    .map((did) => ({ did, labels: {} }))
+                    .concat(pref.labelers.map((labeler) => ({
+                    ...labeler,
+                    labels: {},
+                })));
+            }
+            else if (index_1.AppBskyActorDefs.isSavedFeedsPrefV2(pref) &&
+                index_1.AppBskyActorDefs.validateSavedFeedsPrefV2(pref).success) {
+                prefs.savedFeeds = pref.items;
+            }
+            else if (index_1.AppBskyActorDefs.isSavedFeedsPref(pref) &&
+                index_1.AppBskyActorDefs.validateSavedFeedsPref(pref).success) {
+                // saved and pinned feeds
+                prefs.feeds.saved = pref.saved;
+                prefs.feeds.pinned = pref.pinned;
+            }
+            else if (index_1.AppBskyActorDefs.isPersonalDetailsPref(pref) &&
+                index_1.AppBskyActorDefs.validatePersonalDetailsPref(pref).success) {
+                // birth date (irl)
+                if (pref.birthDate) {
+                    prefs.birthDate = new Date(pref.birthDate);
+                }
+            }
+            else if (index_1.AppBskyActorDefs.isFeedViewPref(pref) &&
+                index_1.AppBskyActorDefs.validateFeedViewPref(pref).success) {
+                // feed view preferences
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, feed, ...v } = pref;
+                prefs.feedViewPrefs[pref.feed] = { ...FEED_VIEW_PREF_DEFAULTS, ...v };
+            }
+            else if (index_1.AppBskyActorDefs.isThreadViewPref(pref) &&
+                index_1.AppBskyActorDefs.validateThreadViewPref(pref).success) {
+                // thread view preferences
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.threadViewPrefs = { ...prefs.threadViewPrefs, ...v };
+            }
+            else if (index_1.AppBskyActorDefs.isInterestsPref(pref) &&
+                index_1.AppBskyActorDefs.validateInterestsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.interests = { ...prefs.interests, ...v };
+            }
+            else if (index_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+                index_1.AppBskyActorDefs.validateMutedWordsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.moderationPrefs.mutedWords = v.items;
+            }
+            else if (index_1.AppBskyActorDefs.isHiddenPostsPref(pref) &&
+                index_1.AppBskyActorDefs.validateHiddenPostsPref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.moderationPrefs.hiddenPosts = v.items;
+            }
+            else if (index_1.AppBskyActorDefs.isBskyAppStatePref(pref) &&
+                index_1.AppBskyActorDefs.validateBskyAppStatePref(pref).success) {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { $type, ...v } = pref;
+                prefs.bskyAppState.queuedNudges = v.queuedNudges || [];
+                prefs.bskyAppState.activeProgressGuide = v.activeProgressGuide;
             }
         }
-    }
-    /**
-     * Resume a pre-existing session with this agent.
-     */
-    async resumeSession(session) {
-        try {
-            this.session = session;
-            const res = await this.api.com.atproto.server.getSession();
-            if (res.data.did !== this.session.did) {
-                throw new xrpc_2.XRPCError(xrpc_2.ResponseType.InvalidRequest, 'Invalid session', 'InvalidDID');
-            }
-            this.session.email = res.data.email;
-            this.session.handle = res.data.handle;
-            this.session.emailConfirmed = res.data.emailConfirmed;
-            this.session.emailAuthFactor = res.data.emailAuthFactor;
-            this.session.active = res.data.active ?? true;
-            this.session.status = res.data.status;
-            this._updateApiEndpoint(res.data.didDoc);
-            this._persistSession?.('update', this.session);
-            return res;
-        }
-        catch (e) {
-            this.session = undefined;
-            if (e instanceof xrpc_2.XRPCError) {
-                /*
-                 * `ExpiredToken` and `InvalidToken` are handled in
-                 * `this_refreshSession`, and emit an `expired` event there.
-                 *
-                 * Everything else is handled here.
-                 */
-                if ([1, 408, 425, 429, 500, 502, 503, 504, 522, 524].includes(e.status)) {
-                    this._persistSession?.('network-error', undefined);
+        /*
+         * If `prefs.savedFeeds` is undefined, no `savedFeedsPrefV2` exists, which
+         * means we want to try to migrate if needed.
+         *
+         * If v1 prefs exist, they will be migrated to v2.
+         *
+         * If no v1 prefs exist, the user is either new, or could be old and has
+         * never edited their feeds.
+         */
+        if (prefs.savedFeeds == null) {
+            const { saved, pinned } = prefs.feeds;
+            if (saved && pinned) {
+                const uniqueMigratedSavedFeeds = new Map();
+                // insert Following feed first
+                uniqueMigratedSavedFeeds.set('timeline', {
+                    id: common_web_1.TID.nextStr(),
+                    type: 'timeline',
+                    value: 'following',
+                    pinned: true,
+                });
+                // use pinned as source of truth for feed order
+                for (const uri of pinned) {
+                    const type = (0, util_1.getSavedFeedType)(uri);
+                    // only want supported types
+                    if (type === 'unknown')
+                        continue;
+                    uniqueMigratedSavedFeeds.set(uri, {
+                        id: common_web_1.TID.nextStr(),
+                        type,
+                        value: uri,
+                        pinned: true,
+                    });
                 }
-                else {
-                    this._persistSession?.('expired', undefined);
+                for (const uri of saved) {
+                    if (!uniqueMigratedSavedFeeds.has(uri)) {
+                        const type = (0, util_1.getSavedFeedType)(uri);
+                        // only want supported types
+                        if (type === 'unknown')
+                            continue;
+                        uniqueMigratedSavedFeeds.set(uri, {
+                            id: common_web_1.TID.nextStr(),
+                            type,
+                            value: uri,
+                            pinned: false,
+                        });
+                    }
                 }
+                prefs.savedFeeds = Array.from(uniqueMigratedSavedFeeds.values());
             }
             else {
-                this._persistSession?.('network-error', undefined);
+                prefs.savedFeeds = [
+                    {
+                        id: common_web_1.TID.nextStr(),
+                        type: 'timeline',
+                        value: 'following',
+                        pinned: true,
+                    },
+                ];
             }
-            throw e;
+            // save to user preferences so this migration doesn't re-occur
+            await this.overwriteSavedFeeds(prefs.savedFeeds);
         }
+        // apply the label prefs
+        for (const pref of labelPrefs) {
+            if (pref.labelerDid) {
+                const labeler = prefs.moderationPrefs.labelers.find((labeler) => labeler.did === pref.labelerDid);
+                if (!labeler)
+                    continue;
+                labeler.labels[pref.label] = pref.visibility;
+            }
+            else {
+                prefs.moderationPrefs.labels[pref.label] =
+                    pref.visibility;
+            }
+        }
+        prefs.moderationPrefs.labels = remapLegacyLabels(prefs.moderationPrefs.labels);
+        // automatically configure the client
+        this.configureLabelers(prefsArrayToLabelerDids(res.data.preferences));
+        return prefs;
+    }
+    async overwriteSavedFeeds(savedFeeds) {
+        savedFeeds.forEach(util_1.validateSavedFeed);
+        const uniqueSavedFeeds = new Map();
+        savedFeeds.forEach((feed) => {
+            // remove and re-insert to preserve order
+            if (uniqueSavedFeeds.has(feed.id)) {
+                uniqueSavedFeeds.delete(feed.id);
+            }
+            uniqueSavedFeeds.set(feed.id, feed);
+        });
+        return this.updateSavedFeedsV2Preferences(() => Array.from(uniqueSavedFeeds.values()));
+    }
+    async updateSavedFeeds(savedFeedsToUpdate) {
+        savedFeedsToUpdate.map(util_1.validateSavedFeed);
+        return this.updateSavedFeedsV2Preferences((savedFeeds) => {
+            return savedFeeds.map((savedFeed) => {
+                const updatedVersion = savedFeedsToUpdate.find((updated) => savedFeed.id === updated.id);
+                if (updatedVersion) {
+                    return {
+                        ...savedFeed,
+                        // only update pinned
+                        pinned: updatedVersion.pinned,
+                    };
+                }
+                return savedFeed;
+            });
+        });
+    }
+    async addSavedFeeds(savedFeeds) {
+        const toSave = savedFeeds.map((f) => ({
+            ...f,
+            id: common_web_1.TID.nextStr(),
+        }));
+        toSave.forEach(util_1.validateSavedFeed);
+        return this.updateSavedFeedsV2Preferences((savedFeeds) => [
+            ...savedFeeds,
+            ...toSave,
+        ]);
+    }
+    async removeSavedFeeds(ids) {
+        return this.updateSavedFeedsV2Preferences((savedFeeds) => [
+            ...savedFeeds.filter((feed) => !ids.find((id) => feed.id === id)),
+        ]);
     }
     /**
-     * Internal helper to add authorization headers to requests.
+     * @deprecated use `overwriteSavedFeeds`
      */
-    _addHeaders(reqHeaders) {
-        if (!reqHeaders.authorization && this.session?.accessJwt) {
-            reqHeaders = {
-                ...reqHeaders,
-                authorization: `Bearer ${this.session.accessJwt}`,
-            };
-        }
-        if (this.proxyHeader) {
-            reqHeaders = {
-                ...reqHeaders,
-                'atproto-proxy': this.proxyHeader,
-            };
-        }
-        const labelerHeaderName = 'atproto-accept-labelers';
-        const labelerHeaders = AtpAgent.appLabelers
-            .map((str) => `${str};redact`)
-            .concat(this.labelersHeader.filter((str) => str.startsWith('did:')));
-        // Besides labelers configured via appLabelers and labelersHeader
-        // respect any additional labelers configured via the request headers
-        if (reqHeaders[labelerHeaderName]) {
-            labelerHeaders.push(
-            // Allow for headers to be comma-separated with or without spaces in between by trimming after split
-            ...reqHeaders[labelerHeaderName].split(',').map((str) => str.trim()));
-        }
-        reqHeaders = {
-            ...reqHeaders,
-            [labelerHeaderName]: labelerHeaders.join(', '),
-        };
-        return reqHeaders;
+    async setSavedFeeds(saved, pinned) {
+        return this.updateFeedPreferences(() => ({
+            saved,
+            pinned,
+        }));
     }
     /**
-     * Internal fetch handler which adds access-token management
+     * @deprecated use `addSavedFeeds`
      */
-    async _fetch(reqUri, reqMethod, reqHeaders, reqBody) {
-        if (!AtpAgent.fetch) {
-            throw new Error('AtpAgent fetch() method not configured');
-        }
-        // wait for any active session-refreshes to finish
-        await this._refreshSessionPromise;
-        // send the request
-        let res = await AtpAgent.fetch(reqUri, reqMethod, this._addHeaders(reqHeaders), reqBody);
-        // handle session-refreshes as needed
-        if (isErrorResponse(res, ['ExpiredToken']) && this.session?.refreshJwt) {
-            // attempt refresh
-            await this.refreshSession();
-            // resend the request with the new access token
-            res = await AtpAgent.fetch(reqUri, reqMethod, this._addHeaders(reqHeaders), reqBody);
-        }
-        return res;
+    async addSavedFeed(v) {
+        return this.updateFeedPreferences((saved, pinned) => ({
+            saved: [...saved.filter((uri) => uri !== v), v],
+            pinned,
+        }));
     }
     /**
-     * Internal helper to refresh sessions
-     * - Wraps the actual implementation in a promise-guard to ensure only
-     *   one refresh is attempted at a time.
+     * @deprecated use `removeSavedFeeds`
      */
-    async refreshSession() {
-        if (this._refreshSessionPromise) {
-            return this._refreshSessionPromise;
-        }
-        this._refreshSessionPromise = this._refreshSessionInner();
-        try {
-            await this._refreshSessionPromise;
-        }
-        finally {
-            this._refreshSessionPromise = undefined;
-        }
+    async removeSavedFeed(v) {
+        return this.updateFeedPreferences((saved, pinned) => ({
+            saved: saved.filter((uri) => uri !== v),
+            pinned: pinned.filter((uri) => uri !== v),
+        }));
     }
     /**
-     * Internal helper to refresh sessions (actual behavior)
+     * @deprecated use `addSavedFeeds` or `updateSavedFeeds`
      */
-    async _refreshSessionInner() {
-        if (!AtpAgent.fetch) {
-            throw new Error('AtpAgent fetch() method not configured');
+    async addPinnedFeed(v) {
+        return this.updateFeedPreferences((saved, pinned) => ({
+            saved: [...saved.filter((uri) => uri !== v), v],
+            pinned: [...pinned.filter((uri) => uri !== v), v],
+        }));
+    }
+    /**
+     * @deprecated use `updateSavedFeeds` or `removeSavedFeeds`
+     */
+    async removePinnedFeed(v) {
+        return this.updateFeedPreferences((saved, pinned) => ({
+            saved,
+            pinned: pinned.filter((uri) => uri !== v),
+        }));
+    }
+    async setAdultContentEnabled(v) {
+        await this.updatePreferences((prefs) => {
+            let adultContentPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isAdultContentPref(pref) &&
+                index_1.AppBskyActorDefs.validateAdultContentPref(pref).success);
+            if (adultContentPref) {
+                adultContentPref.enabled = v;
+            }
+            else {
+                adultContentPref = {
+                    $type: 'app.bsky.actor.defs#adultContentPref',
+                    enabled: v,
+                };
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isAdultContentPref(pref))
+                .concat([adultContentPref]);
+        });
+    }
+    async setContentLabelPref(key, value, labelerDid) {
+        if (labelerDid) {
+            (0, syntax_1.ensureValidDid)(labelerDid);
         }
-        if (!this.session?.refreshJwt) {
-            return;
+        await this.updatePreferences((prefs) => {
+            let labelPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isContentLabelPref(pref) &&
+                index_1.AppBskyActorDefs.validateContentLabelPref(pref).success &&
+                pref.label === key &&
+                pref.labelerDid === labelerDid);
+            let legacyLabelPref;
+            if (labelPref) {
+                labelPref.visibility = value;
+            }
+            else {
+                labelPref = {
+                    $type: 'app.bsky.actor.defs#contentLabelPref',
+                    label: key,
+                    labelerDid,
+                    visibility: value,
+                };
+            }
+            if (index_1.AppBskyActorDefs.isContentLabelPref(labelPref)) {
+                // is global
+                if (!labelPref.labelerDid) {
+                    const legacyLabelValue = {
+                        'graphic-media': 'gore',
+                        porn: 'nsfw',
+                        sexual: 'suggestive',
+                    }[labelPref.label];
+                    // if it's a legacy label, double-write the legacy label
+                    if (legacyLabelValue) {
+                        legacyLabelPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isContentLabelPref(pref) &&
+                            index_1.AppBskyActorDefs.validateContentLabelPref(pref).success &&
+                            pref.label === legacyLabelValue &&
+                            pref.labelerDid === undefined);
+                        if (legacyLabelPref) {
+                            legacyLabelPref.visibility = value;
+                        }
+                        else {
+                            legacyLabelPref = {
+                                $type: 'app.bsky.actor.defs#contentLabelPref',
+                                label: legacyLabelValue,
+                                labelerDid: undefined,
+                                visibility: value,
+                            };
+                        }
+                    }
+                }
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isContentLabelPref(pref) ||
+                !(pref.label === key && pref.labelerDid === labelerDid))
+                .concat([labelPref])
+                .filter((pref) => {
+                if (!legacyLabelPref)
+                    return true;
+                return (!index_1.AppBskyActorDefs.isContentLabelPref(pref) ||
+                    !(pref.label === legacyLabelPref.label &&
+                        pref.labelerDid === undefined));
+            })
+                .concat(legacyLabelPref ? [legacyLabelPref] : []);
+        });
+    }
+    async addLabeler(did) {
+        const prefs = await this.updatePreferences((prefs) => {
+            let labelersPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isLabelersPref(pref) &&
+                index_1.AppBskyActorDefs.validateLabelersPref(pref).success);
+            if (!labelersPref) {
+                labelersPref = {
+                    $type: 'app.bsky.actor.defs#labelersPref',
+                    labelers: [],
+                };
+            }
+            if (index_1.AppBskyActorDefs.isLabelersPref(labelersPref)) {
+                let labelerPrefItem = labelersPref.labelers.find((labeler) => labeler.did === did);
+                if (!labelerPrefItem) {
+                    labelerPrefItem = {
+                        did,
+                    };
+                    labelersPref.labelers.push(labelerPrefItem);
+                }
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isLabelersPref(pref))
+                .concat([labelersPref]);
+        });
+        // automatically configure the client
+        this.configureLabelers(prefsArrayToLabelerDids(prefs));
+    }
+    async removeLabeler(did) {
+        const prefs = await this.updatePreferences((prefs) => {
+            let labelersPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isLabelersPref(pref) &&
+                index_1.AppBskyActorDefs.validateLabelersPref(pref).success);
+            if (!labelersPref) {
+                labelersPref = {
+                    $type: 'app.bsky.actor.defs#labelersPref',
+                    labelers: [],
+                };
+            }
+            if (index_1.AppBskyActorDefs.isLabelersPref(labelersPref)) {
+                labelersPref.labelers = labelersPref.labelers.filter((labeler) => labeler.did !== did);
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isLabelersPref(pref))
+                .concat([labelersPref]);
+        });
+        // automatically configure the client
+        this.configureLabelers(prefsArrayToLabelerDids(prefs));
+    }
+    async setPersonalDetails({ birthDate, }) {
+        birthDate = birthDate instanceof Date ? birthDate.toISOString() : birthDate;
+        await this.updatePreferences((prefs) => {
+            let personalDetailsPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isPersonalDetailsPref(pref) &&
+                index_1.AppBskyActorDefs.validatePersonalDetailsPref(pref).success);
+            if (personalDetailsPref) {
+                personalDetailsPref.birthDate = birthDate;
+            }
+            else {
+                personalDetailsPref = {
+                    $type: 'app.bsky.actor.defs#personalDetailsPref',
+                    birthDate,
+                };
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isPersonalDetailsPref(pref))
+                .concat([personalDetailsPref]);
+        });
+    }
+    async setFeedViewPrefs(feed, pref) {
+        await this.updatePreferences((prefs) => {
+            const existing = prefs.findLast((pref) => index_1.AppBskyActorDefs.isFeedViewPref(pref) &&
+                index_1.AppBskyActorDefs.validateFeedViewPref(pref).success &&
+                pref.feed === feed);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isFeedViewPref(pref) || p.feed !== feed)
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#feedViewPref', feed }]);
+        });
+    }
+    async setThreadViewPrefs(pref) {
+        await this.updatePreferences((prefs) => {
+            const existing = prefs.findLast((pref) => index_1.AppBskyActorDefs.isThreadViewPref(pref) &&
+                index_1.AppBskyActorDefs.validateThreadViewPref(pref).success);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isThreadViewPref(p))
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#threadViewPref' }]);
+        });
+    }
+    async setInterestsPref(pref) {
+        await this.updatePreferences((prefs) => {
+            const existing = prefs.findLast((pref) => index_1.AppBskyActorDefs.isInterestsPref(pref) &&
+                index_1.AppBskyActorDefs.validateInterestsPref(pref).success);
+            if (existing) {
+                pref = { ...existing, ...pref };
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isInterestsPref(p))
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#interestsPref' }]);
+        });
+    }
+    async upsertMutedWords(newMutedWords) {
+        await this.updatePreferences((prefs) => {
+            let mutedWordsPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+                index_1.AppBskyActorDefs.validateMutedWordsPref(pref).success);
+            if (mutedWordsPref && index_1.AppBskyActorDefs.isMutedWordsPref(mutedWordsPref)) {
+                for (const updatedWord of newMutedWords) {
+                    let foundMatch = false;
+                    const sanitizedUpdatedValue = (0, util_1.sanitizeMutedWordValue)(updatedWord.value);
+                    // was trimmed down to an empty string e.g. single `#`
+                    if (!sanitizedUpdatedValue)
+                        continue;
+                    for (const existingItem of mutedWordsPref.items) {
+                        if (existingItem.value === sanitizedUpdatedValue) {
+                            existingItem.targets = Array.from(new Set([...existingItem.targets, ...updatedWord.targets]));
+                            foundMatch = true;
+                            break;
+                        }
+                    }
+                    if (!foundMatch) {
+                        mutedWordsPref.items.push({
+                            ...updatedWord,
+                            value: sanitizedUpdatedValue,
+                        });
+                    }
+                }
+            }
+            else {
+                // if the pref doesn't exist, create it
+                mutedWordsPref = {
+                    items: newMutedWords.map((w) => ({
+                        ...w,
+                        value: (0, util_1.sanitizeMutedWordValue)(w.value),
+                    })),
+                };
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isMutedWordsPref(p))
+                .concat([
+                { ...mutedWordsPref, $type: 'app.bsky.actor.defs#mutedWordsPref' },
+            ]);
+        });
+    }
+    async updateMutedWord(mutedWord) {
+        await this.updatePreferences((prefs) => {
+            const mutedWordsPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+                index_1.AppBskyActorDefs.validateMutedWordsPref(pref).success);
+            if (mutedWordsPref && index_1.AppBskyActorDefs.isMutedWordsPref(mutedWordsPref)) {
+                for (const existingItem of mutedWordsPref.items) {
+                    if (existingItem.value === mutedWord.value) {
+                        existingItem.targets = mutedWord.targets;
+                        break;
+                    }
+                }
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isMutedWordsPref(p))
+                .concat([
+                { ...mutedWordsPref, $type: 'app.bsky.actor.defs#mutedWordsPref' },
+            ]);
+        });
+    }
+    async removeMutedWord(mutedWord) {
+        await this.updatePreferences((prefs) => {
+            const mutedWordsPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isMutedWordsPref(pref) &&
+                index_1.AppBskyActorDefs.validateMutedWordsPref(pref).success);
+            if (mutedWordsPref && index_1.AppBskyActorDefs.isMutedWordsPref(mutedWordsPref)) {
+                for (let i = 0; i < mutedWordsPref.items.length; i++) {
+                    const existing = mutedWordsPref.items[i];
+                    if (existing.value === mutedWord.value) {
+                        mutedWordsPref.items.splice(i, 1);
+                        break;
+                    }
+                }
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isMutedWordsPref(p))
+                .concat([
+                { ...mutedWordsPref, $type: 'app.bsky.actor.defs#mutedWordsPref' },
+            ]);
+        });
+    }
+    async hidePost(postUri) {
+        await this.updateHiddenPost(postUri, 'hide');
+    }
+    async unhidePost(postUri) {
+        await this.updateHiddenPost(postUri, 'unhide');
+    }
+    async bskyAppQueueNudges(nudges) {
+        await this.updatePreferences((prefs) => {
+            let bskyAppStatePref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isBskyAppStatePref(pref) &&
+                index_1.AppBskyActorDefs.validateBskyAppStatePref(pref).success);
+            bskyAppStatePref = bskyAppStatePref || {};
+            nudges = Array.isArray(nudges) ? nudges : [nudges];
+            bskyAppStatePref.queuedNudges = (bskyAppStatePref.queuedNudges || []).concat(nudges);
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isBskyAppStatePref(p))
+                .concat([
+                {
+                    ...bskyAppStatePref,
+                    $type: 'app.bsky.actor.defs#bskyAppStatePref',
+                },
+            ]);
+        });
+    }
+    async bskyAppDismissNudges(nudges) {
+        await this.updatePreferences((prefs) => {
+            let bskyAppStatePref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isBskyAppStatePref(pref) &&
+                index_1.AppBskyActorDefs.validateBskyAppStatePref(pref).success);
+            bskyAppStatePref = bskyAppStatePref || {};
+            nudges = Array.isArray(nudges) ? nudges : [nudges];
+            bskyAppStatePref.queuedNudges = (bskyAppStatePref.queuedNudges || []).filter((nudge) => !nudges.includes(nudge));
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isBskyAppStatePref(p))
+                .concat([
+                {
+                    ...bskyAppStatePref,
+                    $type: 'app.bsky.actor.defs#bskyAppStatePref',
+                },
+            ]);
+        });
+    }
+    async bskyAppSetActiveProgressGuide(guide) {
+        if (guide &&
+            !index_1.AppBskyActorDefs.validateBskyAppProgressGuide(guide).success) {
+            throw new Error('Invalid progress guide');
         }
-        // send the refresh request
-        const url = new URL((this.pdsUrl || this.service).origin);
-        url.pathname = `/xrpc/${REFRESH_SESSION}`;
-        const res = await AtpAgent.fetch(url.toString(), 'POST', {
-            authorization: `Bearer ${this.session.refreshJwt}`,
-        }, undefined);
-        if (isErrorResponse(res, ['ExpiredToken', 'InvalidToken'])) {
-            // failed due to a bad refresh token
-            this.session = undefined;
-            this._persistSession?.('expired', undefined);
+        await this.updatePreferences((prefs) => {
+            let bskyAppStatePref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isBskyAppStatePref(pref) &&
+                index_1.AppBskyActorDefs.validateBskyAppStatePref(pref).success);
+            bskyAppStatePref = bskyAppStatePref || {};
+            bskyAppStatePref.activeProgressGuide = guide;
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isBskyAppStatePref(p))
+                .concat([
+                {
+                    ...bskyAppStatePref,
+                    $type: 'app.bsky.actor.defs#bskyAppStatePref',
+                },
+            ]);
+        });
+    }
+    /**
+     * This function updates the preferences of a user and allows for a callback function to be executed
+     * before the update.
+     * @param cb - cb is a callback function that takes in a single parameter of type
+     * AppBskyActorDefs.Preferences and returns either a boolean or void. This callback function is used to
+     * update the preferences of the user. The function is called with the current preferences as an
+     * argument and if the callback returns false, the preferences are not updated.
+     */
+    async updatePreferences(cb) {
+        try {
+            await __classPrivateFieldGet(this, _Agent_prefsLock, "f").acquireAsync();
+            const res = await this.app.bsky.actor.getPreferences({});
+            const newPrefs = cb(res.data.preferences);
+            if (newPrefs === false) {
+                return res.data.preferences;
+            }
+            await this.app.bsky.actor.putPreferences({
+                preferences: newPrefs,
+            });
+            return newPrefs;
         }
-        else if (isNewSessionObject(this._baseClient, res.body)) {
-            // succeeded, update the session
-            this.session = {
-                ...(this.session || {}),
-                accessJwt: res.body.accessJwt,
-                refreshJwt: res.body.refreshJwt,
-                handle: res.body.handle,
-                did: res.body.did,
-            };
-            this._updateApiEndpoint(res.body.didDoc);
-            this._persistSession?.('update', this.session);
+        finally {
+            __classPrivateFieldGet(this, _Agent_prefsLock, "f").release();
         }
-        // else: other failures should be ignored - the issue will
-        // propagate in the _fetch() handler's second attempt to run
-        // the request
+    }
+    async updateHiddenPost(postUri, action) {
+        await this.updatePreferences((prefs) => {
+            let pref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isHiddenPostsPref(pref) &&
+                index_1.AppBskyActorDefs.validateHiddenPostsPref(pref).success);
+            if (pref && index_1.AppBskyActorDefs.isHiddenPostsPref(pref)) {
+                pref.items =
+                    action === 'hide'
+                        ? Array.from(new Set([...pref.items, postUri]))
+                        : pref.items.filter((uri) => uri !== postUri);
+            }
+            else {
+                if (action === 'hide') {
+                    pref = {
+                        $type: 'app.bsky.actor.defs#hiddenPostsPref',
+                        items: [postUri],
+                    };
+                }
+            }
+            return prefs
+                .filter((p) => !index_1.AppBskyActorDefs.isInterestsPref(p))
+                .concat([{ ...pref, $type: 'app.bsky.actor.defs#hiddenPostsPref' }]);
+        });
     }
     /**
-     * Helper to update the pds endpoint dynamically.
-     *
-     * The session methods (create, resume, refresh) may respond with the user's
-     * did document which contains the user's canonical PDS endpoint. That endpoint
-     * may differ from the endpoint used to contact the server. We capture that
-     * PDS endpoint and update the client to use that given endpoint for future
-     * requests. (This helps ensure smooth migrations between PDSes, especially
-     * when the PDSes are operated by a single org.)
+     * A helper specifically for updating feed preferences
      */
-    _updateApiEndpoint(didDoc) {
-        if ((0, common_web_1.isValidDidDoc)(didDoc)) {
-            const endpoint = (0, common_web_1.getPdsEndpoint)(didDoc);
-            this.pdsUrl = endpoint ? new URL(endpoint) : undefined;
-        }
-        this.api.xrpc.uri = this.pdsUrl || this.service;
+    async updateFeedPreferences(cb) {
+        let res;
+        await this.updatePreferences((prefs) => {
+            let feedsPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isSavedFeedsPref(pref) &&
+                index_1.AppBskyActorDefs.validateSavedFeedsPref(pref).success);
+            if (feedsPref) {
+                res = cb(feedsPref.saved, feedsPref.pinned);
+                feedsPref.saved = res.saved;
+                feedsPref.pinned = res.pinned;
+            }
+            else {
+                res = cb([], []);
+                feedsPref = {
+                    $type: 'app.bsky.actor.defs#savedFeedsPref',
+                    saved: res.saved,
+                    pinned: res.pinned,
+                };
+            }
+            return prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isSavedFeedsPref(pref))
+                .concat([feedsPref]);
+        });
+        return res;
+    }
+    async updateSavedFeedsV2Preferences(cb) {
+        let maybeMutatedSavedFeeds = [];
+        await this.updatePreferences((prefs) => {
+            let existingV2Pref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isSavedFeedsPrefV2(pref) &&
+                index_1.AppBskyActorDefs.validateSavedFeedsPrefV2(pref).success);
+            let existingV1Pref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isSavedFeedsPref(pref) &&
+                index_1.AppBskyActorDefs.validateSavedFeedsPref(pref).success);
+            if (existingV2Pref) {
+                maybeMutatedSavedFeeds = cb(existingV2Pref.items);
+                existingV2Pref = {
+                    ...existingV2Pref,
+                    items: maybeMutatedSavedFeeds,
+                };
+            }
+            else {
+                maybeMutatedSavedFeeds = cb([]);
+                existingV2Pref = {
+                    $type: 'app.bsky.actor.defs#savedFeedsPrefV2',
+                    items: maybeMutatedSavedFeeds,
+                };
+            }
+            // enforce ordering, pinned then saved
+            const pinned = existingV2Pref.items.filter((i) => i.pinned);
+            const saved = existingV2Pref.items.filter((i) => !i.pinned);
+            existingV2Pref.items = pinned.concat(saved);
+            let updatedPrefs = prefs
+                .filter((pref) => !index_1.AppBskyActorDefs.isSavedFeedsPrefV2(pref))
+                .concat(existingV2Pref);
+            /*
+             * If there's a v2 pref present, it means this account was migrated from v1
+             * to v2. During the transition period, we double write v2 prefs back to
+             * v1, but NOT the other way around.
+             */
+            if (existingV1Pref) {
+                const { saved, pinned } = existingV1Pref;
+                const v2Compat = (0, util_1.savedFeedsToUriArrays)(
+                // v1 only supports feeds and lists
+                existingV2Pref.items.filter((i) => ['feed', 'list'].includes(i.type)));
+                existingV1Pref = {
+                    ...existingV1Pref,
+                    saved: Array.from(new Set([...saved, ...v2Compat.saved])),
+                    pinned: Array.from(new Set([...pinned, ...v2Compat.pinned])),
+                };
+                updatedPrefs = updatedPrefs
+                    .filter((pref) => !index_1.AppBskyActorDefs.isSavedFeedsPref(pref))
+                    .concat(existingV1Pref);
+            }
+            return updatedPrefs;
+        });
+        return maybeMutatedSavedFeeds;
     }
 }
-exports.AtpAgent = AtpAgent;
+exports.Agent = Agent;
+_Agent_prefsLock = new WeakMap();
 /**
- * The `fetch` implementation; must be implemented for your platform.
+ * Helper to transform the legacy content preferences.
  */
-Object.defineProperty(AtpAgent, "fetch", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: xrpc_2.defaultFetchHandler
-});
+function adjustLegacyContentLabelPref(pref) {
+    let visibility = pref.visibility;
+    // adjust legacy values
+    if (visibility === 'show') {
+        visibility = 'ignore';
+    }
+    return { ...pref, visibility };
+}
 /**
- * The labelers to be used across all requests with the takedown capability
+ * Re-maps legacy labels to new labels on READ. Does not save these changes to
+ * the user's preferences.
  */
-Object.defineProperty(AtpAgent, "appLabelers", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: [const_1.BSKY_LABELER_DID]
-});
-function isErrorObject(v) {
-    return xrpc_1.errorResponseBody.safeParse(v).success;
-}
-function isErrorResponse(res, errorNames) {
-    if (res.status !== 400) {
-        return false;
-    }
-    if (!isErrorObject(res.body)) {
-        return false;
+function remapLegacyLabels(labels) {
+    const _labels = { ...labels };
+    const legacyToNewMap = {
+        gore: 'graphic-media',
+        nsfw: 'porn',
+        suggestive: 'sexual',
+    };
+    for (const labelName in _labels) {
+        const newLabelName = legacyToNewMap[labelName];
+        if (newLabelName) {
+            _labels[newLabelName] = _labels[labelName];
+        }
     }
-    return (typeof res.body.error === 'string' && errorNames.includes(res.body.error));
+    return _labels;
 }
-function isNewSessionObject(client, v) {
-    try {
-        client.xrpc.lex.assertValidXrpcOutput('com.atproto.server.refreshSession', v);
-        return true;
-    }
-    catch {
-        return false;
+/**
+ * A helper to get the currently enabled labelers from the full preferences array
+ */
+function prefsArrayToLabelerDids(prefs) {
+    const labelersPref = prefs.findLast((pref) => index_1.AppBskyActorDefs.isLabelersPref(pref) &&
+        index_1.AppBskyActorDefs.validateLabelersPref(pref).success);
+    let dids = [];
+    if (labelersPref) {
+        dids = labelersPref.labelers.map((labeler) => labeler.did);
     }
+    return dids;
+}
+function isBskyPrefs(v) {
+    return (v &&
+        typeof v === 'object' &&
+        'moderationPrefs' in v &&
+        isModPrefs(v.moderationPrefs));
+}
+function isModPrefs(v) {
+    return v && typeof v === 'object' && 'labelers' in v;
 }
 //# sourceMappingURL=agent.js.map