@atproto/api 0.12.5 → 0.12.7

package/src/bsky-agent.ts

@@ -1,4 +1,5 @@
 import { AtUri, ensureValidDid } from '@atproto/syntax'
+import { TID } from '@atproto/common-web'
 import { AtpAgent } from './agent'
 import {
   AppBskyFeedPost,
@@ -19,7 +20,12 @@ import {
   ModerationPrefs,
 } from './moderation/types'
 import { DEFAULT_LABEL_SETTINGS } from './moderation/const/labels'
-import { sanitizeMutedWordValue } from './util'
+import {
+  sanitizeMutedWordValue,
+  validateSavedFeed,
+  savedFeedsToUriArrays,
+  getSavedFeedType,
+} from './util'
 import { interpretLabelValueDefinitions } from './moderation'
 
 const FEED_VIEW_PREF_DEFAULTS = {
@@ -365,6 +371,8 @@ export class BskyAgent extends AtpAgent {
         saved: undefined,
         pinned: undefined,
       },
+      // @ts-ignore populating below
+      savedFeeds: undefined,
       feedViewPrefs: {
         home: {
           ...FEED_VIEW_PREF_DEFAULTS,
@@ -412,6 +420,11 @@ export class BskyAgent extends AtpAgent {
               labels: {},
             })),
           )
+      } else if (
+        AppBskyActorDefs.isSavedFeedsPrefV2(pref) &&
+        AppBskyActorDefs.validateSavedFeedsPrefV2(pref).success
+      ) {
+        prefs.savedFeeds = pref.items
       } else if (
         AppBskyActorDefs.isSavedFeedsPref(pref) &&
         AppBskyActorDefs.validateSavedFeedsPref(pref).success
@@ -467,6 +480,75 @@ export class BskyAgent extends AtpAgent {
       }
     }
 
+    /*
+     * 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 === undefined) {
+      const { saved, pinned } = prefs.feeds
+
+      if (saved && pinned) {
+        const uniqueMigratedSavedFeeds: Map<
+          string,
+          AppBskyActorDefs.SavedFeed
+        > = new Map()
+
+        // insert Following feed first
+        uniqueMigratedSavedFeeds.set('timeline', {
+          id: TID.nextStr(),
+          type: 'timeline',
+          value: 'following',
+          pinned: true,
+        })
+
+        // use pinned as source of truth for feed order
+        for (const uri of pinned) {
+          const type = getSavedFeedType(uri)
+          // only want supported types
+          if (type === 'unknown') continue
+          uniqueMigratedSavedFeeds.set(uri, {
+            id: TID.nextStr(),
+            type,
+            value: uri,
+            pinned: true,
+          })
+        }
+
+        for (const uri of saved) {
+          if (!uniqueMigratedSavedFeeds.has(uri)) {
+            const type = getSavedFeedType(uri)
+            // only want supported types
+            if (type === 'unknown') continue
+            uniqueMigratedSavedFeeds.set(uri, {
+              id: TID.nextStr(),
+              type,
+              value: uri,
+              pinned: false,
+            })
+          }
+        }
+
+        prefs.savedFeeds = Array.from(uniqueMigratedSavedFeeds.values())
+      } else {
+        prefs.savedFeeds = [
+          {
+            id: TID.nextStr(),
+            type: 'timeline',
+            value: 'following',
+            pinned: true,
+          },
+        ]
+      }
+
+      // 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) {
@@ -491,6 +573,63 @@ export class BskyAgent extends AtpAgent {
     return prefs
   }
 
+  async overwriteSavedFeeds(savedFeeds: AppBskyActorDefs.SavedFeed[]) {
+    savedFeeds.forEach(validateSavedFeed)
+    const uniqueSavedFeeds = new Map<string, AppBskyActorDefs.SavedFeed>()
+    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 updateSavedFeedsV2Preferences(this, () =>
+      Array.from(uniqueSavedFeeds.values()),
+    )
+  }
+
+  async updateSavedFeeds(savedFeedsToUpdate: AppBskyActorDefs.SavedFeed[]) {
+    savedFeedsToUpdate.map(validateSavedFeed)
+    return updateSavedFeedsV2Preferences(this, (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: Pick<AppBskyActorDefs.SavedFeed, 'type' | 'value' | 'pinned'>[],
+  ) {
+    const toSave: AppBskyActorDefs.SavedFeed[] = savedFeeds.map((f) => ({
+      ...f,
+      id: TID.nextStr(),
+    }))
+    toSave.forEach(validateSavedFeed)
+    return updateSavedFeedsV2Preferences(this, (savedFeeds) => [
+      ...savedFeeds,
+      ...toSave,
+    ])
+  }
+
+  async removeSavedFeeds(ids: string[]) {
+    return updateSavedFeedsV2Preferences(this, (savedFeeds) => [
+      ...savedFeeds.filter((feed) => !ids.find((id) => feed.id === id)),
+    ])
+  }
+
+  /**
+   * @deprecated use `overwriteSavedFeeds`
+   */
   async setSavedFeeds(saved: string[], pinned: string[]) {
     return updateFeedPreferences(this, () => ({
       saved,
@@ -498,6 +637,9 @@ export class BskyAgent extends AtpAgent {
     }))
   }
 
+  /**
+   * @deprecated use `addSavedFeeds`
+   */
   async addSavedFeed(v: string) {
     return updateFeedPreferences(this, (saved: string[], pinned: string[]) => ({
       saved: [...saved.filter((uri) => uri !== v), v],
@@ -505,6 +647,9 @@ export class BskyAgent extends AtpAgent {
     }))
   }
 
+  /**
+   * @deprecated use `removeSavedFeeds`
+   */
   async removeSavedFeed(v: string) {
     return updateFeedPreferences(this, (saved: string[], pinned: string[]) => ({
       saved: saved.filter((uri) => uri !== v),
@@ -512,6 +657,9 @@ export class BskyAgent extends AtpAgent {
     }))
   }
 
+  /**
+   * @deprecated use `addSavedFeeds` or `updateSavedFeeds`
+   */
   async addPinnedFeed(v: string) {
     return updateFeedPreferences(this, (saved: string[], pinned: string[]) => ({
       saved: [...saved.filter((uri) => uri !== v), v],
@@ -519,6 +667,9 @@ export class BskyAgent extends AtpAgent {
     }))
   }
 
+  /**
+   * @deprecated use `updateSavedFeeds` or `removeSavedFeeds`
+   */
   async removePinnedFeed(v: string) {
     return updateFeedPreferences(this, (saved: string[], pinned: string[]) => ({
       saved,
@@ -945,6 +1096,76 @@ async function updateFeedPreferences(
   return res
 }
 
+async function updateSavedFeedsV2Preferences(
+  agent: BskyAgent,
+  cb: (
+    savedFeedsPref: AppBskyActorDefs.SavedFeed[],
+  ) => AppBskyActorDefs.SavedFeed[],
+): Promise<AppBskyActorDefs.SavedFeed[]> {
+  let maybeMutatedSavedFeeds: AppBskyActorDefs.SavedFeed[] = []
+
+  await updatePreferences(agent, (prefs: AppBskyActorDefs.Preferences) => {
+    let existingV2Pref = prefs.findLast(
+      (pref) =>
+        AppBskyActorDefs.isSavedFeedsPrefV2(pref) &&
+        AppBskyActorDefs.validateSavedFeedsPrefV2(pref).success,
+    ) as AppBskyActorDefs.SavedFeedsPrefV2 | undefined
+    let existingV1Pref = prefs.findLast(
+      (pref) =>
+        AppBskyActorDefs.isSavedFeedsPref(pref) &&
+        AppBskyActorDefs.validateSavedFeedsPref(pref).success,
+    ) as AppBskyActorDefs.SavedFeedsPref | undefined
+
+    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) => !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 = 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) => !AppBskyActorDefs.isSavedFeedsPref(pref))
+        .concat(existingV1Pref)
+    }
+
+    return updatedPrefs
+  })
+
+  return maybeMutatedSavedFeeds
+}
+
 /**
  * Helper to transform the legacy content preferences.
  */

package/src/client/lexicons.ts

@@ -3822,6 +3822,7 @@ export const schemaDict = {
             'lex:app.bsky.actor.defs#adultContentPref',
             'lex:app.bsky.actor.defs#contentLabelPref',
             'lex:app.bsky.actor.defs#savedFeedsPref',
+            'lex:app.bsky.actor.defs#savedFeedsPrefV2',
             'lex:app.bsky.actor.defs#personalDetailsPref',
             'lex:app.bsky.actor.defs#feedViewPref',
             'lex:app.bsky.actor.defs#threadViewPref',
@@ -3860,6 +3861,38 @@ export const schemaDict = {
           },
         },
       },
+      savedFeed: {
+        type: 'object',
+        required: ['id', 'type', 'value', 'pinned'],
+        properties: {
+          id: {
+            type: 'string',
+          },
+          type: {
+            type: 'string',
+            knownValues: ['feed', 'list', 'timeline'],
+          },
+          value: {
+            type: 'string',
+          },
+          pinned: {
+            type: 'boolean',
+          },
+        },
+      },
+      savedFeedsPrefV2: {
+        type: 'object',
+        required: ['items'],
+        properties: {
+          items: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:app.bsky.actor.defs#savedFeed',
+            },
+          },
+        },
+      },
       savedFeedsPref: {
         type: 'object',
         required: ['pinned', 'saved'],
@@ -8375,6 +8408,9 @@ export const schemaDict = {
               'lex:tools.ozone.moderation.defs#modEventAcknowledge',
               'lex:tools.ozone.moderation.defs#modEventEscalate',
               'lex:tools.ozone.moderation.defs#modEventMute',
+              'lex:tools.ozone.moderation.defs#modEventUnmute',
+              'lex:tools.ozone.moderation.defs#modEventMuteReporter',
+              'lex:tools.ozone.moderation.defs#modEventUnmuteReporter',
               'lex:tools.ozone.moderation.defs#modEventEmail',
               'lex:tools.ozone.moderation.defs#modEventResolveAppeal',
               'lex:tools.ozone.moderation.defs#modEventDivert',
@@ -8434,6 +8470,9 @@ export const schemaDict = {
               'lex:tools.ozone.moderation.defs#modEventAcknowledge',
               'lex:tools.ozone.moderation.defs#modEventEscalate',
               'lex:tools.ozone.moderation.defs#modEventMute',
+              'lex:tools.ozone.moderation.defs#modEventUnmute',
+              'lex:tools.ozone.moderation.defs#modEventMuteReporter',
+              'lex:tools.ozone.moderation.defs#modEventUnmuteReporter',
               'lex:tools.ozone.moderation.defs#modEventEmail',
               'lex:tools.ozone.moderation.defs#modEventResolveAppeal',
               'lex:tools.ozone.moderation.defs#modEventDivert',
@@ -8513,6 +8552,10 @@ export const schemaDict = {
             type: 'string',
             format: 'datetime',
           },
+          muteReportingUntil: {
+            type: 'string',
+            format: 'datetime',
+          },
           lastReviewedBy: {
             type: 'string',
             format: 'did',
@@ -8636,6 +8679,11 @@ export const schemaDict = {
           comment: {
             type: 'string',
           },
+          isReporterMuted: {
+            type: 'boolean',
+            description:
+              "Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject.",
+          },
           reportType: {
             type: 'ref',
             ref: 'lex:com.atproto.moderation.defs#reasonType',
@@ -8704,6 +8752,30 @@ export const schemaDict = {
           },
         },
       },
+      modEventMuteReporter: {
+        type: 'object',
+        description: 'Mute incoming reports from an account',
+        required: ['durationInHours'],
+        properties: {
+          comment: {
+            type: 'string',
+          },
+          durationInHours: {
+            type: 'integer',
+            description: 'Indicates how long the account should remain muted.',
+          },
+        },
+      },
+      modEventUnmuteReporter: {
+        type: 'object',
+        description: 'Unmute incoming reports from an account',
+        properties: {
+          comment: {
+            type: 'string',
+            description: 'Describe reasoning behind the reversal.',
+          },
+        },
+      },
       modEventEmail: {
         type: 'object',
         description: 'Keep a log of outgoing email to a user',
@@ -9088,6 +9160,9 @@ export const schemaDict = {
                   'lex:tools.ozone.moderation.defs#modEventLabel',
                   'lex:tools.ozone.moderation.defs#modEventReport',
                   'lex:tools.ozone.moderation.defs#modEventMute',
+                  'lex:tools.ozone.moderation.defs#modEventUnmute',
+                  'lex:tools.ozone.moderation.defs#modEventMuteReporter',
+                  'lex:tools.ozone.moderation.defs#modEventUnmuteReporter',
                   'lex:tools.ozone.moderation.defs#modEventReverseTakedown',
                   'lex:tools.ozone.moderation.defs#modEventUnmute',
                   'lex:tools.ozone.moderation.defs#modEventEmail',
@@ -9396,6 +9471,11 @@ export const schemaDict = {
               description:
                 "By default, we don't include muted subjects in the results. Set this to true to include them.",
             },
+            onlyMuted: {
+              type: 'boolean',
+              description:
+                'When set to true, only muted subjects and reporters will be returned.',
+            },
             reviewState: {
               type: 'string',
               description: 'Specify when fetching subjects in a certain state',

package/src/client/types/app/bsky/actor/defs.ts

@@ -132,6 +132,7 @@ export type Preferences = (
   | AdultContentPref
   | ContentLabelPref
   | SavedFeedsPref
+  | SavedFeedsPrefV2
   | PersonalDetailsPref
   | FeedViewPref
   | ThreadViewPref
@@ -178,6 +179,43 @@ export function validateContentLabelPref(v: unknown): ValidationResult {
   return lexicons.validate('app.bsky.actor.defs#contentLabelPref', v)
 }
 
+export interface SavedFeed {
+  id: string
+  type: 'feed' | 'list' | 'timeline' | (string & {})
+  value: string
+  pinned: boolean
+  [k: string]: unknown
+}
+
+export function isSavedFeed(v: unknown): v is SavedFeed {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#savedFeed'
+  )
+}
+
+export function validateSavedFeed(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#savedFeed', v)
+}
+
+export interface SavedFeedsPrefV2 {
+  items: SavedFeed[]
+  [k: string]: unknown
+}
+
+export function isSavedFeedsPrefV2(v: unknown): v is SavedFeedsPrefV2 {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'app.bsky.actor.defs#savedFeedsPrefV2'
+  )
+}
+
+export function validateSavedFeedsPrefV2(v: unknown): ValidationResult {
+  return lexicons.validate('app.bsky.actor.defs#savedFeedsPrefV2', v)
+}
+
 export interface SavedFeedsPref {
   pinned: string[]
   saved: string[]

package/src/client/types/tools/ozone/moderation/defs.ts

@@ -22,6 +22,9 @@ export interface ModEventView {
     | ModEventAcknowledge
     | ModEventEscalate
     | ModEventMute
+    | ModEventUnmute
+    | ModEventMuteReporter
+    | ModEventUnmuteReporter
     | ModEventEmail
     | ModEventResolveAppeal
     | ModEventDivert
@@ -61,6 +64,9 @@ export interface ModEventViewDetail {
     | ModEventAcknowledge
     | ModEventEscalate
     | ModEventMute
+    | ModEventUnmute
+    | ModEventMuteReporter
+    | ModEventUnmuteReporter
     | ModEventEmail
     | ModEventResolveAppeal
     | ModEventDivert
@@ -105,6 +111,7 @@ export interface SubjectStatusView {
   /** Sticky comment on the subject. */
   comment?: string
   muteUntil?: string
+  muteReportingUntil?: string
   lastReviewedBy?: string
   lastReviewedAt?: string
   lastReportedAt?: string
@@ -237,6 +244,8 @@ export function validateModEventComment(v: unknown): ValidationResult {
 /** Report a subject */
 export interface ModEventReport {
   comment?: string
+  /** Set to true if the reporter was muted from reporting at the time of the event. These reports won't impact the reviewState of the subject. */
+  isReporterMuted?: boolean
   reportType: ComAtprotoModerationDefs.ReasonType
   [k: string]: unknown
 }
@@ -346,6 +355,53 @@ export function validateModEventUnmute(v: unknown): ValidationResult {
   return lexicons.validate('tools.ozone.moderation.defs#modEventUnmute', v)
 }
 
+/** Mute incoming reports from an account */
+export interface ModEventMuteReporter {
+  comment?: string
+  /** Indicates how long the account should remain muted. */
+  durationInHours: number
+  [k: string]: unknown
+}
+
+export function isModEventMuteReporter(v: unknown): v is ModEventMuteReporter {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.moderation.defs#modEventMuteReporter'
+  )
+}
+
+export function validateModEventMuteReporter(v: unknown): ValidationResult {
+  return lexicons.validate(
+    'tools.ozone.moderation.defs#modEventMuteReporter',
+    v,
+  )
+}
+
+/** Unmute incoming reports from an account */
+export interface ModEventUnmuteReporter {
+  /** Describe reasoning behind the reversal. */
+  comment?: string
+  [k: string]: unknown
+}
+
+export function isModEventUnmuteReporter(
+  v: unknown,
+): v is ModEventUnmuteReporter {
+  return (
+    isObj(v) &&
+    hasProp(v, '$type') &&
+    v.$type === 'tools.ozone.moderation.defs#modEventUnmuteReporter'
+  )
+}
+
+export function validateModEventUnmuteReporter(v: unknown): ValidationResult {
+  return lexicons.validate(
+    'tools.ozone.moderation.defs#modEventUnmuteReporter',
+    v,
+  )
+}
+
 /** Keep a log of outgoing email to a user */
 export interface ModEventEmail {
   /** The subject line of the email sent to the user. */

package/src/client/types/tools/ozone/moderation/emitEvent.ts

@@ -21,6 +21,9 @@ export interface InputSchema {
     | ToolsOzoneModerationDefs.ModEventLabel
     | ToolsOzoneModerationDefs.ModEventReport
     | ToolsOzoneModerationDefs.ModEventMute
+    | ToolsOzoneModerationDefs.ModEventUnmute
+    | ToolsOzoneModerationDefs.ModEventMuteReporter
+    | ToolsOzoneModerationDefs.ModEventUnmuteReporter
     | ToolsOzoneModerationDefs.ModEventReverseTakedown
     | ToolsOzoneModerationDefs.ModEventUnmute
     | ToolsOzoneModerationDefs.ModEventEmail

package/src/client/types/tools/ozone/moderation/queryStatuses.ts

@@ -22,6 +22,8 @@ export interface QueryParams {
   reviewedBefore?: string
   /** By default, we don't include muted subjects in the results. Set this to true to include them. */
   includeMuted?: boolean
+  /** When set to true, only muted subjects and reporters will be returned. */
+  onlyMuted?: boolean
   /** Specify when fetching subjects in a certain state */
   reviewState?: string
   ignoreSubjects?: string[]

package/src/types.ts

@@ -112,10 +112,14 @@ export interface BskyInterestsPreference {
  * Bluesky preferences
  */
 export interface BskyPreferences {
+  /**
+   * @deprecated use `savedFeeds`
+   */
   feeds: {
     saved?: string[]
     pinned?: string[]
   }
+  savedFeeds: AppBskyActorDefs.SavedFeed[]
   feedViewPrefs: Record<string, BskyFeedViewPreference>
   threadViewPrefs: BskyThreadViewPreference
   moderationPrefs: ModerationPrefs

package/src/util.ts

@@ -1,6 +1,78 @@
+import { AtUri } from '@atproto/syntax'
+import { TID } from '@atproto/common-web'
+
+import { AppBskyActorDefs } from './client'
+
 export function sanitizeMutedWordValue(value: string) {
   return value
     .trim()
     .replace(/^#(?!\ufe0f)/, '')
     .replace(/[\r\n\u00AD\u2060\u200D\u200C\u200B]+/, '')
 }
+
+export function savedFeedsToUriArrays(
+  savedFeeds: AppBskyActorDefs.SavedFeed[],
+): {
+  pinned: string[]
+  saved: string[]
+} {
+  const pinned: string[] = []
+  const saved: string[] = []
+
+  for (const feed of savedFeeds) {
+    if (feed.pinned) {
+      pinned.push(feed.value)
+      // saved in v1 includes pinned
+      saved.push(feed.value)
+    } else {
+      saved.push(feed.value)
+    }
+  }
+
+  return {
+    pinned,
+    saved,
+  }
+}
+
+/**
+ * Get the type of a saved feed, used by deprecated methods for backwards
+ * compat. Should not be used moving forward. *Invalid URIs will throw.*
+ *
+ * @param uri - The AT URI of the saved feed
+ */
+export function getSavedFeedType(
+  uri: string,
+): AppBskyActorDefs.SavedFeed['type'] {
+  const urip = new AtUri(uri)
+
+  switch (urip.collection) {
+    case 'app.bsky.feed.generator':
+      return 'feed'
+    case 'app.bsky.graph.list':
+      return 'list'
+    default:
+      return 'unknown'
+  }
+}
+
+export function validateSavedFeed(savedFeed: AppBskyActorDefs.SavedFeed) {
+  new TID(savedFeed.id)
+
+  if (['feed', 'list'].includes(savedFeed.type)) {
+    const uri = new AtUri(savedFeed.value)
+    const isFeed = uri.collection === 'app.bsky.feed.generator'
+    const isList = uri.collection === 'app.bsky.graph.list'
+
+    if (savedFeed.type === 'feed' && !isFeed) {
+      throw new Error(
+        `Saved feed of type 'feed' must be a feed, got ${uri.collection}`,
+      )
+    }
+    if (savedFeed.type === 'list' && !isList) {
+      throw new Error(
+        `Saved feed of type 'list' must be a list, got ${uri.collection}`,
+      )
+    }
+  }
+}