@atproto/bsky 0.0.14 → 0.0.16

package/dist/services/moderation/index.d.ts

@@ -1,13 +1,13 @@
-import { Selectable } from 'kysely';
 import { CID } from 'multiformats/cid';
 import { AtUri } from '@atproto/syntax';
 import { PrimaryDatabase } from '../../db';
-import { ModerationAction, ModerationReport } from '../../db/tables/moderation';
 import { ModerationViews } from './views';
 import { ImageUriBuilder } from '../../image/uri';
+import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
 import { ImageInvalidator } from '../../image/invalidator';
 import { RepoRef, RepoBlobRef } from '../../lexicon/types/com/atproto/admin/defs';
-import { Main as StrongRef } from '../../lexicon/types/com/atproto/repo/strongRef';
+import { ModEventType, ModerationEventRow, ModerationEventRowWithHandle, ModerationSubjectStatusRow, ReversibleModerationEvent, SubjectInfo } from './types';
+import { ModerationEvent } from '../../db/tables/moderation';
 export declare class ModerationService {
     db: PrimaryDatabase;
     imgUriBuilder: ImageUriBuilder;
@@ -15,52 +15,52 @@ export declare class ModerationService {
     constructor(db: PrimaryDatabase, imgUriBuilder: ImageUriBuilder, imgInvalidator: ImageInvalidator);
     static creator(imgUriBuilder: ImageUriBuilder, imgInvalidator: ImageInvalidator): (db: PrimaryDatabase) => ModerationService;
     views: ModerationViews;
-    getAction(id: number): Promise<ModerationActionRow | undefined>;
-    getActionOrThrow(id: number): Promise<ModerationActionRow>;
-    getActions(opts: {
+    getEvent(id: number): Promise<ModerationEventRow | undefined>;
+    getEventOrThrow(id: number): Promise<ModerationEventRow>;
+    getEvents(opts: {
         subject?: string;
+        createdBy?: string;
         limit: number;
         cursor?: string;
-    }): Promise<ModerationActionRow[]>;
-    getReport(id: number): Promise<ModerationReportRow | undefined>;
-    getReports(opts: {
-        subject?: string;
-        resolved?: boolean;
-        actionType?: string;
-        limit: number;
+        includeAllUserRecords: boolean;
+        types: ModerationEvent['action'][];
+        sortDirection?: 'asc' | 'desc';
+    }): Promise<{
         cursor?: string;
-        ignoreSubjects?: string[];
-        reverse?: boolean;
-        reporters?: string[];
-        actionedBy?: string;
-    }): Promise<ModerationReportRowWithHandle[]>;
-    getReportOrThrow(id: number): Promise<ModerationReportRow>;
-    getCurrentActions(subject: {
+        events: ModerationEventRowWithHandle[];
+    }>;
+    getReport(id: number): Promise<ModerationEventRow | undefined>;
+    getCurrentStatus(subject: {
         did: string;
     } | {
         uri: AtUri;
     } | {
         cids: CID[];
     }): Promise<{
+        did: string;
         id: number;
-        action: "com.atproto.admin.defs#takedown" | "com.atproto.admin.defs#flag" | "com.atproto.admin.defs#acknowledge" | "com.atproto.admin.defs#escalate";
-        reason: string;
-        createdBy: string;
         createdAt: string;
-        durationInHours: number | null;
-        createLabelVals: string | null;
-        negateLabelVals: string | null;
-        subjectCid: string | null;
-        subjectDid: string;
-        subjectType: "com.atproto.repo.strongRef" | "com.atproto.admin.defs#repoRef";
-        subjectUri: string | null;
-        reversedAt: string | null;
-        reversedBy: string | null;
-        reversedReason: string | null;
-        expiresAt: string | null;
+        updatedAt: string;
+        reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+        blobCids: string[] | null;
+        comment: string | null;
+        lastReportedAt: string | null;
+        lastReviewedAt: string | null;
+        muteUntil: string | null;
+        lastReviewedBy: string | null;
+        takendown: boolean;
+        suspendUntil: string | null;
+        recordCid: string | null;
+        recordPath: string;
     }[]>;
-    logAction(info: {
-        action: ModerationActionRow['action'];
+    buildSubjectInfo(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+        cid: CID;
+    }, subjectBlobCids?: CID[]): SubjectInfo;
+    logEvent(info: {
+        event: ModEventType;
         subject: {
             did: string;
         } | {
@@ -68,19 +68,31 @@ export declare class ModerationService {
             cid: CID;
         };
         subjectBlobCids?: CID[];
-        reason: string;
-        createLabelVals?: string[];
-        negateLabelVals?: string[];
         createdBy: string;
         createdAt?: Date;
-        durationInHours?: number;
-    }): Promise<ModerationActionRow>;
-    getActionsDueForReversal(): Promise<ModerationActionRow[]>;
-    revertAction({ id, createdBy, createdAt, reason, }: ReversibleModerationAction): Promise<{
-        result: ModerationActionRow;
+    }): Promise<ModerationEventRow>;
+    getLastReversibleEventForSubject({ did, muteUntil, recordPath, suspendUntil, }: ModerationSubjectStatusRow): Promise<{
+        id: number;
+        createdBy: string;
+        createdAt: string;
+        comment: string | null;
+        createLabelVals: string | null;
+        negateLabelVals: string | null;
+        durationInHours: number | null;
+        action: "com.atproto.admin.defs#modEventTakedown" | "com.atproto.admin.defs#modEventReverseTakedown" | "com.atproto.admin.defs#modEventComment" | "com.atproto.admin.defs#modEventReport" | "com.atproto.admin.defs#modEventLabel" | "com.atproto.admin.defs#modEventAcknowledge" | "com.atproto.admin.defs#modEventEscalate" | "com.atproto.admin.defs#modEventMute" | "com.atproto.admin.defs#modEventEmail";
+        subjectCid: string | null;
+        subjectDid: string;
+        subjectType: "com.atproto.repo.strongRef" | "com.atproto.admin.defs#repoRef";
+        subjectUri: string | null;
+        expiresAt: string | null;
+        meta: Record<string, string | boolean> | null;
+        legacyRefId: number | null;
+    } | null | undefined>;
+    getSubjectsDueForReversal(): Promise<ModerationSubjectStatusRow[]>;
+    revertState({ createdBy, createdAt, comment, action, subject, }: ReversibleModerationEvent): Promise<{
+        result: ModerationEventRow;
         restored?: TakedownSubjects;
     }>;
-    logReverseAction(info: ReversibleModerationAction): Promise<ModerationActionRow>;
     takedownRepo(info: {
         takedownId: number;
         did: string;
@@ -97,14 +109,8 @@ export declare class ModerationService {
     reverseTakedownRecord(info: {
         uri: AtUri;
     }): Promise<void>;
-    resolveReports(info: {
-        reportIds: number[];
-        actionId: number;
-        createdBy: string;
-        createdAt?: Date;
-    }): Promise<void>;
     report(info: {
-        reasonType: ModerationReportRow['reasonType'];
+        reasonType: NonNullable<ModerationEventRow['meta']>['reportType'];
         reason?: string;
         subject: {
             did: string;
@@ -114,28 +120,85 @@ export declare class ModerationService {
         };
         reportedBy: string;
         createdAt?: Date;
-    }): Promise<ModerationReportRow>;
+    }): Promise<ModerationEventRow>;
+    getSubjectStatuses({ cursor, limit, takendown, reviewState, reviewedAfter, reviewedBefore, reportedAfter, reportedBefore, includeMuted, ignoreSubjects, sortDirection, lastReviewedBy, sortField, subject, }: {
+        cursor?: string;
+        limit?: number;
+        takendown?: boolean;
+        reviewedBefore?: string;
+        reviewState?: ModerationSubjectStatusRow['reviewState'];
+        reviewedAfter?: string;
+        reportedAfter?: string;
+        reportedBefore?: string;
+        includeMuted?: boolean;
+        subject?: string;
+        ignoreSubjects?: string[];
+        sortDirection: 'asc' | 'desc';
+        lastReviewedBy?: string;
+        sortField: 'lastReviewedAt' | 'lastReportedAt';
+    }): Promise<{
+        statuses: (import("kysely").Selection<{
+            record: import("../../db/tables/record").Record;
+            subscription: import("../../db/tables/subscription").Subscription;
+            post: import("../../db/tables/post").Post;
+            duplicate_record: import("../../db/tables/duplicate-record").DuplicateRecord;
+            profile: import("../../db/tables/profile").Profile;
+            profile_agg: import("../../db/tables/profile-agg").ProfileAgg;
+            post_embed_image: import("../../db/tables/post-embed").PostEmbedImage;
+            post_embed_external: import("../../db/tables/post-embed").PostEmbedExternal;
+            post_embed_record: import("../../db/tables/post-embed").PostEmbedRecord;
+            post_agg: import("../../db/tables/post-agg").PostAgg;
+            repost: import("../../db/tables/repost").Repost;
+            thread_gate: import("../../db/tables/thread-gate").ThreadGate;
+            feed_item: import("../../db/tables/feed-item").FeedItem;
+            follow: import("../../db/tables/follow").Follow;
+            like: import("../../db/tables/like").Like;
+            list: import("../../db/tables/list").List;
+            list_item: import("../../db/tables/list-item").ListItem;
+            list_mute: import("../../db/tables/list-mute").ListMute;
+            list_block: import("../../db/tables/list-block").ListBlock;
+            mute: import("../../db/tables/mute").Mute;
+            actor_block: import("../../db/tables/actor-block").ActorBlock;
+            feed_generator: import("../../db/tables/feed-generator").FeedGenerator;
+            actor: import("kysely/dist/cjs/util/type-utils").Nullable<import("../../db/tables/actor").Actor>;
+            actor_state: import("../../db/tables/actor-state").ActorState;
+            actor_sync: import("../../db/tables/actor-sync").ActorSync;
+            notification: import("../../db/tables/notification").Notification;
+            notification_push_token: import("../../db/tables/notification-push-token").NotificationPushToken;
+            did_cache: import("../../db/tables/did-cache").DidCache;
+            label: import("../../db/tables/label").Label;
+            moderation_event: ModerationEvent;
+            moderation_subject_status: import("../../db/tables/moderation").ModerationSubjectStatus;
+            algo_whats_hot_view: import("../../db/tables/algo").AlgoWhatsHotView;
+            view_param: import("../../db/tables/view-param").ViewParam;
+            suggested_follow: import("../../db/tables/suggested-follow").SuggestedFollow;
+            suggested_feed: import("../../db/tables/suggested-feed").SuggestedFeed;
+        }, "actor" | "moderation_subject_status", "actor.handle as handle"> & {
+            did: string;
+            id: number;
+            createdAt: string;
+            updatedAt: string;
+            reviewState: "com.atproto.admin.defs#reviewOpen" | "com.atproto.admin.defs#reviewEscalated" | "com.atproto.admin.defs#reviewClosed";
+            blobCids: string[] | null;
+            comment: string | null;
+            lastReportedAt: string | null;
+            lastReviewedAt: string | null;
+            muteUntil: string | null;
+            lastReviewedBy: string | null;
+            takendown: boolean;
+            suspendUntil: string | null;
+            recordCid: string | null;
+            recordPath: string;
+        })[];
+        cursor: string | undefined;
+    }>;
+    isSubjectTakendown(subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+    }): Promise<boolean>;
 }
 export declare type TakedownSubjects = {
     did: string;
     subjects: (RepoRef | RepoBlobRef | StrongRef)[];
 };
-export declare type ModerationActionRow = Selectable<ModerationAction>;
-export declare type ReversibleModerationAction = Pick<ModerationActionRow, 'id' | 'createdBy' | 'reason'> & {
-    createdAt?: Date;
-};
-export declare type ModerationReportRow = Selectable<ModerationReport>;
-export declare type ModerationReportRowWithHandle = ModerationReportRow & {
-    handle?: string | null;
-};
-export declare type SubjectInfo = {
-    subjectType: 'com.atproto.admin.defs#repoRef';
-    subjectDid: string;
-    subjectUri: null;
-    subjectCid: null;
-} | {
-    subjectType: 'com.atproto.repo.strongRef';
-    subjectDid: string;
-    subjectUri: string;
-    subjectCid: string;
-};

package/dist/services/moderation/pagination.d.ts

@@ -0,0 +1,36 @@
+import { Cursor, GenericKeyset } from '../../db/pagination';
+declare type StatusKeysetParam = {
+    lastReviewedAt: string | null;
+    lastReportedAt: string | null;
+    id: number;
+};
+export declare class StatusKeyset extends GenericKeyset<StatusKeysetParam, Cursor> {
+    labelResult(result: StatusKeysetParam): Cursor;
+    labeledResultToCursor(labeled: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    cursorToLabeledResult(cursor: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    unpackCursor(cursorStr?: string): Cursor | undefined;
+    getSql(labeled?: Cursor, direction?: 'asc' | 'desc'): import("kysely").RawBuilder<unknown> | undefined;
+}
+declare type TimeIdKeysetParam = {
+    id: number;
+    createdAt: string;
+};
+declare type TimeIdResult = TimeIdKeysetParam;
+export declare class TimeIdKeyset extends GenericKeyset<TimeIdKeysetParam, Cursor> {
+    labelResult(result: TimeIdResult): Cursor;
+    labeledResultToCursor(labeled: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+    cursorToLabeledResult(cursor: Cursor): {
+        primary: string;
+        secondary: string;
+    };
+}
+export {};

package/dist/services/moderation/status.d.ts

@@ -0,0 +1,13 @@
+import { AtUri } from '@atproto/syntax';
+import { PrimaryDatabase } from '../../db';
+import { ModerationSubjectStatus } from '../../db/tables/moderation';
+import { ModerationEventRow } from './types';
+import { CID } from 'multiformats/cid';
+export declare const adjustModerationSubjectStatus: (db: PrimaryDatabase, moderationEvent: ModerationEventRow, blobCids?: CID[]) => Promise<import("kysely").InsertResult | null>;
+declare type ModerationSubjectStatusFilter = Pick<ModerationSubjectStatus, 'did'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath'> | Pick<ModerationSubjectStatus, 'did' | 'recordPath' | 'recordCid'>;
+export declare const getModerationSubjectStatus: (db: PrimaryDatabase, filters: ModerationSubjectStatusFilter) => Promise<{} | undefined>;
+export declare const getStatusIdentifierFromSubject: (subject: string | AtUri) => {
+    did: string;
+    recordPath: string;
+};
+export {};

package/dist/services/moderation/types.d.ts

@@ -0,0 +1,35 @@
+import { Selectable } from 'kysely';
+import { ModerationEvent, ModerationSubjectStatus } from '../../db/tables/moderation';
+import { AtUri } from '@atproto/syntax';
+import { CID } from 'multiformats/cid';
+import { ComAtprotoAdminDefs } from '@atproto/api';
+export declare type SubjectInfo = {
+    subjectType: 'com.atproto.admin.defs#repoRef';
+    subjectDid: string;
+    subjectUri: null;
+    subjectCid: null;
+} | {
+    subjectType: 'com.atproto.repo.strongRef';
+    subjectDid: string;
+    subjectUri: string;
+    subjectCid: string;
+};
+export declare type ModerationEventRow = Selectable<ModerationEvent>;
+export declare type ReversibleModerationEvent = Pick<ModerationEventRow, 'createdBy' | 'comment' | 'action'> & {
+    createdAt?: Date;
+    subject: {
+        did: string;
+    } | {
+        uri: AtUri;
+        cid: CID;
+    };
+};
+export declare type ModerationEventRowWithHandle = ModerationEventRow & {
+    subjectHandle?: string | null;
+    creatorHandle?: string | null;
+};
+export declare type ModerationSubjectStatusRow = Selectable<ModerationSubjectStatus>;
+export declare type ModerationSubjectStatusRowWithHandle = ModerationSubjectStatusRow & {
+    handle: string | null;
+};
+export declare type ModEventType = ComAtprotoAdminDefs.ModEventTakedown | ComAtprotoAdminDefs.ModEventAcknowledge | ComAtprotoAdminDefs.ModEventEscalate | ComAtprotoAdminDefs.ModEventComment | ComAtprotoAdminDefs.ModEventLabel | ComAtprotoAdminDefs.ModEventReport | ComAtprotoAdminDefs.ModEventMute | ComAtprotoAdminDefs.ModEventReverseTakedown;

package/dist/services/moderation/views.d.ts

@@ -1,37 +1,41 @@
-import { Selectable } from 'kysely';
 import { BlobRef } from '@atproto/lexicon';
 import { Database } from '../../db';
 import { Actor } from '../../db/tables/actor';
 import { Record as RecordRow } from '../../db/tables/record';
-import { ModerationAction } from '../../db/tables/moderation';
-import { RepoView, RepoViewDetail, RecordView, RecordViewDetail, ActionView, ActionViewDetail, ReportView, ReportViewDetail, BlobView } from '../../lexicon/types/com/atproto/admin/defs';
+import { ModEventView, RepoView, RepoViewDetail, RecordView, RecordViewDetail, ReportViewDetail, BlobView, SubjectStatusView, ModEventViewDetail } from '../../lexicon/types/com/atproto/admin/defs';
 import { OutputSchema as ReportOutput } from '../../lexicon/types/com/atproto/moderation/createReport';
 import { Label } from '../../lexicon/types/com/atproto/label/defs';
-import { ModerationReportRowWithHandle } from '.';
+import { ModerationEventRowWithHandle, ModerationSubjectStatusRowWithHandle } from './types';
 export declare class ModerationViews {
     private db;
     constructor(db: Database);
     repo(result: RepoResult): Promise<RepoView>;
     repo(result: RepoResult[]): Promise<RepoView[]>;
+    event(result: EventResult): Promise<ModEventView>;
+    event(result: EventResult[]): Promise<ModEventView[]>;
+    eventDetail(result: EventResult): Promise<ModEventViewDetail>;
     repoDetail(result: RepoResult): Promise<RepoViewDetail>;
     record(result: RecordResult): Promise<RecordView>;
     record(result: RecordResult[]): Promise<RecordView[]>;
     recordDetail(result: RecordResult): Promise<RecordViewDetail>;
-    action(result: ActionResult): Promise<ActionView>;
-    action(result: ActionResult[]): Promise<ActionView[]>;
-    actionDetail(result: ActionResult): Promise<ActionViewDetail>;
-    report(result: ReportResult): Promise<ReportView>;
-    report(result: ReportResult[]): Promise<ReportView[]>;
     reportPublic(report: ReportResult): ReportOutput;
-    reportDetail(result: ReportResult): Promise<ReportViewDetail>;
     subject(result: SubjectResult): Promise<SubjectView>;
     blob(blobs: BlobRef[]): Promise<BlobView[]>;
     labels(subject: string, includeNeg?: boolean): Promise<Label[]>;
+    getSubjectStatus(subject: {
+        did: string;
+        recordPath?: string;
+    } | {
+        did: string;
+        recordPath?: string;
+    }[]): Promise<ModerationSubjectStatusRowWithHandle[]>;
+    subjectStatus(result: ModerationSubjectStatusRowWithHandle): SubjectStatusView;
+    subjectStatus(result: ModerationSubjectStatusRowWithHandle[]): SubjectStatusView[];
 }
 declare type RepoResult = Actor;
-declare type ActionResult = Selectable<ModerationAction>;
-declare type ReportResult = ModerationReportRowWithHandle;
+declare type EventResult = ModerationEventRowWithHandle;
+declare type ReportResult = ModerationEventRowWithHandle;
 declare type RecordResult = RecordRow;
-declare type SubjectResult = Pick<ActionResult & ReportResult, 'id' | 'subjectType' | 'subjectDid' | 'subjectUri' | 'subjectCid'>;
-declare type SubjectView = ActionViewDetail['subject'] & ReportViewDetail['subject'];
+declare type SubjectResult = Pick<EventResult & ReportResult, 'id' | 'subjectType' | 'subjectDid' | 'subjectUri' | 'subjectCid'>;
+declare type SubjectView = ModEventViewDetail['subject'] & ReportViewDetail['subject'];
 export {};

package/dist/util/debug.d.ts

@@ -1 +1 @@
-export declare const debugCatch: <Func extends (...args: any[]) => any>(fn: Func) => (...args: any[]) => Promise<any>;
+export declare const debugCatch: <Func extends (...args: any[]) => any>(fn: Func) => (...args: Parameters<Func>) => Promise<ReturnType<Func>>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atproto/bsky",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "license": "MIT",
   "description": "Reference implementation of app.bsky App View (Bluesky API)",
   "keywords": [
@@ -32,17 +32,17 @@
     "pg": "^8.10.0",
     "pino": "^8.15.0",
     "pino-http": "^8.2.1",
-    "sharp": "^0.31.2",
+    "sharp": "^0.32.6",
     "typed-emitter": "^2.1.0",
     "uint8arrays": "3.0.0",
-    "@atproto/api": "^0.6.23",
+    "@atproto/api": "^0.6.24",
     "@atproto/common": "^0.3.3",
-    "@atproto/crypto": "^0.2.3",
-    "@atproto/syntax": "^0.1.4",
-    "@atproto/identity": "^0.3.1",
-    "@atproto/lexicon": "^0.3.0",
-    "@atproto/repo": "^0.3.4",
-    "@atproto/xrpc-server": "^0.4.0"
+    "@atproto/crypto": "^0.3.0",
+    "@atproto/syntax": "^0.1.5",
+    "@atproto/identity": "^0.3.2",
+    "@atproto/lexicon": "^0.3.1",
+    "@atproto/repo": "^0.3.6",
+    "@atproto/xrpc-server": "^0.4.2"
   },
   "devDependencies": {
     "@did-plc/server": "^0.0.1",
@@ -51,13 +51,12 @@
     "@types/express-serve-static-core": "^4.17.36",
     "@types/pg": "^8.6.6",
     "@types/qs": "^6.9.7",
-    "@types/sharp": "^0.31.0",
     "axios": "^0.27.2",
-    "@atproto/api": "^0.6.23",
-    "@atproto/dev-env": "^0.2.14",
-    "@atproto/lex-cli": "^0.2.4",
-    "@atproto/pds": "^0.3.2",
-    "@atproto/xrpc": "^0.4.0"
+    "@atproto/api": "^0.6.24",
+    "@atproto/dev-env": "^0.2.16",
+    "@atproto/lex-cli": "^0.2.5",
+    "@atproto/pds": "^0.3.4",
+    "@atproto/xrpc": "^0.4.1"
   },
   "scripts": {
     "codegen": "lex gen-server ./src/lexicon ../../lexicons/com/atproto/*/* ../../lexicons/app/bsky/*/*",

package/src/api/app/bsky/actor/getSuggestions.ts

@@ -42,12 +42,12 @@ const skeleton = async (
   ctx: Context,
 ): Promise<SkeletonState> => {
   const { db } = ctx
-  const { limit, cursor, viewer } = params
+  const { viewer } = params
+  const alreadyIncluded = parseCursor(params.cursor)
   const { ref } = db.db.dynamic
-  let suggestionsQb = db.db
+  const suggestions = await db.db
     .selectFrom('suggested_follow')
     .innerJoin('actor', 'actor.did', 'suggested_follow.did')
-    .innerJoin('profile_agg', 'profile_agg.did', 'actor.did')
     .where(notSoftDeletedClause(ref('actor')))
     .where('suggested_follow.did', '!=', viewer ?? '')
     .whereNotExists((qb) =>
@@ -57,27 +57,30 @@ const skeleton = async (
         .where('creator', '=', viewer ?? '')
         .whereRef('subjectDid', '=', ref('actor.did')),
     )
+    .if(alreadyIncluded.length > 0, (qb) =>
+      qb.where('suggested_follow.order', 'not in', alreadyIncluded),
+    )
     .selectAll()
-    .select('profile_agg.postsCount as postsCount')
-    .limit(limit)
     .orderBy('suggested_follow.order', 'asc')
+    .execute()
 
-  if (cursor) {
-    const cursorRow = await db.db
-      .selectFrom('suggested_follow')
-      .where('did', '=', cursor)
-      .selectAll()
-      .executeTakeFirst()
-    if (cursorRow) {
-      suggestionsQb = suggestionsQb.where(
-        'suggested_follow.order',
-        '>',
-        cursorRow.order,
-      )
-    }
-  }
-  const suggestions = await suggestionsQb.execute()
-  return { params, suggestions, cursor: suggestions.at(-1)?.did }
+  // always include first two
+  const firstTwo = suggestions.filter(
+    (row) => row.order === 1 || row.order === 2,
+  )
+  const rest = suggestions.filter((row) => row.order !== 1 && row.order !== 2)
+  const limited = firstTwo.concat(shuffle(rest)).slice(0, params.limit)
+
+  // if the result set ends up getting larger, consider using a seed included in the cursor for for the randomized shuffle
+  const cursor =
+    limited.length > 0
+      ? limited
+          .map((row) => row.order.toString())
+          .concat(alreadyIncluded.map((id) => id.toString()))
+          .join(':')
+      : undefined
+
+  return { params, suggestions: limited, cursor }
 }
 
 const hydration = async (state: SkeletonState, ctx: Context) => {
@@ -110,6 +113,27 @@ const presentation = (state: HydrationState) => {
   return { actors: suggestedActors, cursor }
 }
 
+const parseCursor = (cursor?: string): number[] => {
+  if (!cursor) {
+    return []
+  }
+  try {
+    return cursor
+      .split(':')
+      .map((id) => parseInt(id, 10))
+      .filter((id) => !isNaN(id))
+  } catch {
+    return []
+  }
+}
+
+const shuffle = <T>(arr: T[]): T[] => {
+  return arr
+    .map((value) => ({ value, sort: Math.random() }))
+    .sort((a, b) => a.sort - b.sort)
+    .map(({ value }) => value)
+}
+
 type Context = {
   db: Database
   actorService: ActorService

package/src/api/app/bsky/feed/getActorFeeds.ts

@@ -1,4 +1,5 @@
 import { InvalidRequestError } from '@atproto/xrpc-server'
+import { mapDefined } from '@atproto/common'
 import { Server } from '../../../../lexicon'
 import AppContext from '../../../../context'
 import { TimeCidKeyset, paginate } from '../../../../db/pagination'
@@ -42,7 +43,7 @@ export default function (server: Server, ctx: AppContext) {
         throw new InvalidRequestError(`Actor not found: ${actor}`)
       }
 
-      const feeds = feedsRes.map((row) => {
+      const feeds = mapDefined(feedsRes, (row) => {
         const feed = {
           ...row,
           viewer: viewer ? { like: row.viewerLike } : undefined,

package/src/api/app/bsky/feed/getActorLikes.ts

@@ -107,9 +107,7 @@ const noPostBlocks = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return { feed, cursor }
 }
 

package/src/api/app/bsky/feed/getAuthorFeed.ts

@@ -147,9 +147,7 @@ const noBlocksOrMutedReposts = (state: HydrationState) => {
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return { feed, cursor }
 }
 

package/src/api/app/bsky/feed/getFeed.ts

@@ -33,7 +33,7 @@ export default function (server: Server, ctx: AppContext) {
     presentation,
   )
   server.app.bsky.feed.getFeed({
-    auth: ctx.authVerifierAnyAudience,
+    auth: ctx.authOptionalVerifierAnyAudience,
     handler: async ({ params, auth, req }) => {
       const db = ctx.db.getReplica()
       const feedService = ctx.services.feed(db)
@@ -98,22 +98,22 @@ const hydration = async (state: SkeletonState, ctx: Context) => {
 
 const noBlocksOrMutes = (state: HydrationState) => {
   const { viewer } = state.params
-  state.feedItems = state.feedItems.filter(
-    (item) =>
+  state.feedItems = state.feedItems.filter((item) => {
+    if (!viewer) return true
+    return (
       !state.bam.block([viewer, item.postAuthorDid]) &&
       !state.bam.block([viewer, item.originatorDid]) &&
       !state.bam.mute([viewer, item.postAuthorDid]) &&
-      !state.bam.mute([viewer, item.originatorDid]),
-  )
+      !state.bam.mute([viewer, item.originatorDid])
+    )
+  })
   return state
 }
 
 const presentation = (state: HydrationState, ctx: Context) => {
   const { feedService } = ctx
   const { feedItems, cursor, passthrough, params } = state
-  const feed = feedService.views.formatFeed(feedItems, state, {
-    viewer: params.viewer,
-  })
+  const feed = feedService.views.formatFeed(feedItems, state, params.viewer)
   return {
     feed,
     cursor,
@@ -130,7 +130,7 @@ type Context = {
   authorization?: string
 }
 
-type Params = GetFeedParams & { viewer: string }
+type Params = GetFeedParams & { viewer: string | null }
 
 type SkeletonState = {
   params: Params

package/src/api/app/bsky/feed/getFeedGenerator.ts

@@ -55,6 +55,9 @@ export default function (server: Server, ctx: AppContext) {
         feedInfo,
         profiles,
       )
+      if (!feedView) {
+        throw new InvalidRequestError('could not find feed')
+      }
 
       return {
         encoding: 'application/json',