@recursiv/sdk 0.7.57 → 0.7.59

package/dist/resources/protocols.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { DiscoveryLayout, PaginatedResponse, PaginationParams, SingleResponse } from '../types.js';
+import type { CompassFilterMeta, DiscoveryLayout, PaginatedResponse, PaginationParams, SingleResponse } from '../types.js';
 /** Canonical protocol operation names returned by the adapter registry. */
 export declare const PROTOCOL_CAPABILITY_OPERATIONS: readonly ["discover", "stream", "backfill", "search", "resolveIdentity", "fetchProfile", "fetchThread", "publish", "reply", "react", "repost", "follow", "delete", "health", "checkpoint"];
 export declare const PROTOCOL_CAPABILITY_STATUSES: readonly ["supported", "planned", "unsupported"];
@@ -906,7 +906,8 @@ export interface SocialNetwork {
         url: string;
     };
     coverage: string;
-    capabilities: Array<'profile_search' | 'profile_read' | 'original_author_posts' | 'minds_subscription' | 'following_feed' | 'conversation_read' | 'public_trends' | 'trend_feed' | 'popular_accounts' | 'post_search'>;
+    /** `compass_filter`: the Politics filter is served to this viewer (an app offers it only then); listed on every network. */
+    capabilities: Array<'profile_search' | 'profile_read' | 'original_author_posts' | 'minds_subscription' | 'following_feed' | 'conversation_read' | 'public_trends' | 'trend_feed' | 'popular_accounts' | 'post_search' | 'compass_filter'>;
     profileSearchPagination: boolean;
     postSearchAccountRequired?: boolean;
     /** Categories available from the current app configuration. */
@@ -930,8 +931,22 @@ export interface SocialProfile {
     postsCount: number | null;
     /** Nostr only: the NIP-05 name its domain has confirmed for this key ("lyn@primal.net"); `handle` stays the key. */
     nip05?: string;
+    /** A bridge (Bridgy Fed, Mostr) made this account from one on another network (SocialBridge). Present only on a bridged account. */
+    bridge?: SocialBridge;
     subscription: SocialSubscription | null;
 }
+/**
+ * A post or account a bridge copied from another network: Bridgy Fed (`*.brid.gy`), Mostr (`mostr.pub`), or a Nostr
+ * event's NIP-48 `proxy` tag naming no bridge the server knows (`proxy`). `originId` names the original, normalised (a
+ * Bluesky at-uri or DID, an ActivityPub object URL or `user@host`, a Nostr event id or key, a web URL), when the bridge
+ * says. Where the server reads both, feeds, search and the radar already fold a copy into its original; an app that
+ * merges several networks' pages itself can fold the same way: a copy whose original is shown is the same post.
+ */
+export interface SocialBridge {
+    via: 'bridgy_fed' | 'mostr' | 'proxy';
+    protocol: 'bluesky' | 'activitypub' | 'nostr' | 'web';
+    originId?: string;
+}
 export interface SocialSubscription {
     id: string;
     protocol: string;
@@ -990,7 +1005,10 @@ export interface SocialPost {
      * older than 15 minutes when the provider answers in time). Absent: the counts are from this read.
      */
     countsObservedAt?: string;
-    /** Pixel dimensions when the source declares them (Bluesky aspect ratio, Mastodon attachment meta), so a card can take the clip's shape before it loads. */
+    /**
+     * Pixel dimensions when the source declares them (Bluesky aspect ratio, Mastodon attachment meta, Nostr NIP-92 `dim`), so a
+     * card can take the clip's shape before it loads. Each entry of a sensitive post carries `sensitive: true`.
+     */
     media: Array<{
         type: 'image' | 'video';
         url: string;
@@ -998,8 +1016,15 @@ export interface SocialPost {
         poster?: string;
         width?: number;
         height?: number;
+        sensitive?: true;
     }>;
     hasAdditionalContent: boolean;
+    /**
+     * The author marked the post sensitive with one of Minds' sensitive tags (#nsfw, #nudity and the rest), in its text or
+     * among the network's own tags: cover its media as a Minds post flagged NSFW is covered. A post the network itself marks
+     * (a Mastodon sensitive flag or content warning, a Bluesky label, a Nostr content-warning) is never returned at all.
+     */
+    sensitive?: boolean;
     /** At most one independently filtered quoted post. */
     quote?: {
         state: 'available';
@@ -1018,6 +1043,8 @@ export interface SocialPost {
      * to signed-out visitors.
      */
     authorOptOut?: true;
+    /** A bridge (Bridgy Fed, Mostr, a NIP-48 proxy tag) made this post from one on another network (SocialBridge). Present only on a copy read live. */
+    bridge?: SocialBridge;
 }
 export interface SocialPostSearch {
     items: SocialPost[];
@@ -1152,7 +1179,11 @@ export interface SocialRadarMember {
      */
     visitorMedia?: true;
 }
-/** One story on the radar. `breaking` is outlet corroboration inside a short window; `viral` is social velocity above its network's norm. */
+/**
+ * One story on the radar. `breaking` is outlet corroboration inside a short window; `viral` is social velocity above its
+ * network's norm, from two or more people, on a story still gaining engagement, reported by no outlet or by two or more.
+ * `velocity.perHour` is the engagement its posts gained per hour since the last build, counting only posts read on both.
+ */
 export interface SocialRadarCluster {
     id: string;
     /** Verbatim: a World Today headline, a provider topic name or the medoid outlet title. Never generated. */
@@ -1249,7 +1280,9 @@ export interface SocialRadarStoryArchive {
 }
 /**
  * One radar story by id, with its social member posts.
- * `live`: on the current radar (`cluster` and `items` present). `aged_out`: not on this radar, but
+ * `live`: on the current radar (`cluster` and `items` present), or left it sooner than its minimum lifetime after it was
+ * first published (six hours by default), or within the last half hour: then `liveUntil` says until when, and `successor`
+ * names the story on the radar that continues it, if one does. `aged_out`: not on this radar, but
  * held by the story archive (`archive`, and the live story it continues as in `successor`) or seen on
  * one of the last six radars (`archive` null). `unknown`: in neither (never existed, or left longer ago
  * than the archive keeps stories). A server without the story archive leaves `archive` and `successor` out.
@@ -1266,12 +1299,190 @@ export interface SocialRadarStory {
         id: string;
         label: string;
     } | null;
+    /** On a `live` answer for a story no longer on the radar list: when it stops answering `live` and ages out. */
+    liveUntil?: string;
     /**
      * Present when the story was asked for by a World Today edition story's id: the radar story that edition story
      * seeded, and `id` is its radar id, the address to link to. A server that cannot resolve edition story ids answers 400.
      */
     editionStory?: string;
 }
+/**
+ * The Viral read (`getPublicViral`, `getSharedViral`): what is moving fastest on Bluesky, the Fediverse, Nostr and
+ * Minds right now, each measured against its own network's pace, from a snapshot the server's rank tick rebuilds about
+ * every five minutes. A read never reaches a provider or the model. These types mirror the server's
+ * ViralSnapshotContract; a contract test compares them key by key.
+ */
+export type ViralNetwork = 'all' | 'minds' | 'bluesky' | 'activitypub' | 'nostr';
+export type ViralProtocol = 'bluesky' | 'activitypub' | 'nostr' | 'minds';
+/** The networks whose posts the read serves as a `SocialPost`. */
+export type ViralOpenProtocol = 'bluesky' | 'activitypub' | 'nostr';
+/**
+ * `viral`: a measured rate well above its network's baseline (z of 1 or more) with two or more kinds of engagement;
+ * `rising`: a measured rate speeding up (accel of 0.7 or more) on a post under six hours old; `hot`: everything else,
+ * including every post without a measured rate.
+ */
+export type ViralLabel = 'viral' | 'rising' | 'hot';
+/**
+ * `ok`: a build served. `building`: no build yet. `screening`: served, but fewer than 30% of the top 200 posts have
+ * a safety verdict yet. `off`: the read is not enabled for this app (or, on `getSharedViral` only, the API predates it):
+ * no items, and nothing to retry until it is turned on.
+ */
+export type ViralReadStatus = 'ok' | 'building' | 'screening' | 'off';
+/** Every parameter is optional. The server rejects any other parameter with a 400, so only these travel. */
+export interface ViralReadParams {
+    /** Default `all`: every network, with a per-network quota so no one network fills the page. */
+    network?: ViralNetwork;
+    /** A Discover category id: only posts judged into it. */
+    category?: string;
+    /**
+     * `video`: only posts whose own media includes a video. A member's read serves every such video. A visitor's read
+     * (`getSharedViral`) still serves a post's media only where the server cleared it, so some items can arrive with
+     * the video withheld (the card's `media` empty): keep `items.filter(viralItemHasVideo)` for a video-only player.
+     */
+    media?: 'video';
+    /** Page size, default 20. */
+    limit?: 5 | 10 | 20 | 40;
+    /** The previous page's `cursor`. A cursor names its build; one whose build expired (30 minutes) ends the list. */
+    cursor?: string;
+    /** A Politics choice. A visitor (`getSharedViral`) may send only `all` or `hide`; anything else is a 400. */
+    compass?: string;
+}
+/** How fast a post is gathering reactions, reposts and replies (per hour), against its network's baseline. */
+export interface ViralItemVelocity {
+    perHour1h: number;
+    perHour6h: number;
+    /** The 1-hour rate against its network's trailing baseline, from -2 to 4 (1 or more is well above). */
+    z: number;
+    /** ln((1 + perHour1h) / (1 + perHour6h)), from -1 to 2: above 0 is speeding up. */
+    accel: number;
+    /** Readings behind the rate; null for a Minds post. */
+    samples: number | null;
+    spanHours: number;
+    /** The rate comes from two or more readings over time (a Minds post's always does). An unmeasured post is never viral or rising. */
+    measured: boolean;
+    /** Who counted: Bluesky's AppView, one Fediverse server, a third party's report (Primal, for Nostr), or Minds itself. */
+    countsOrigin: 'appview' | 'instance_local' | 'provider_reported' | 'minds';
+    /** Minutes since the counts were last read, when known. */
+    countsAgeMin?: number;
+    /** Present when a third party reported the counts (`Primal`): show them as reported by it, never as verified. */
+    countsReportedBy?: string;
+}
+/** Another post in the same spread group: the same link posted on another network. */
+export interface ViralRef {
+    protocol: ViralProtocol;
+    nativeId: string;
+}
+export interface ViralItemSpread {
+    /** The networks sharing the post's link (its own alone when no other network carries it). */
+    protocols: ViralProtocol[];
+    /** Fediverse: how many servers' trends lists carried the post. */
+    instances?: number;
+    clusterId: null;
+    alsoOn: ViralRef[];
+}
+/** A Minds post's card as the read serves it; open it at /post/:id. A visitor's carries media only where the server cleared it. */
+export interface ViralMindsCard {
+    id: string;
+    title: string | null;
+    text: string;
+    createdAt: string;
+    author: {
+        name: string | null;
+        username: string | null;
+    } | null;
+    media: Array<{
+        type: string;
+        url: string;
+        width: number | null;
+        height: number | null;
+        thumbnailUrl: string | null;
+        hlsUrl: string | null;
+    }>;
+    likeCount: number;
+    repostCount: number;
+    replyCount: number;
+}
+/** What every ranked post carries, whichever network it comes from. */
+export interface ViralItemFields {
+    /** Stable across builds: use it to drop a post already shown. */
+    key: string;
+    label: ViralLabel;
+    score: number;
+    /** 1-based position in this read's ordering, across pages. */
+    rank: number;
+    category: string | null;
+    velocity: ViralItemVelocity;
+    spread: ViralItemSpread;
+}
+/** A ranked Minds post; open it at /post/:id. */
+export interface ViralMindsItem extends ViralItemFields {
+    protocol: 'minds';
+    post: ViralMindsCard;
+}
+/** A ranked Bluesky, Fediverse or Nostr post. */
+export interface ViralSocialItem extends ViralItemFields {
+    protocol: ViralOpenProtocol;
+    post: SocialPost;
+}
+/**
+ * One ranked post: check `protocol` and TypeScript narrows `post` (a `ViralMindsCard` for `minds`, a `SocialPost`
+ * otherwise). No item carries a compass value, an author id, a safety flag or its media kind. A visitor's card keeps
+ * its own images and video only where the server cleared them; a withheld one has empty `media` (a `SocialPost` also
+ * has `hasAdditionalContent: true`). Even under `media: 'video'` a visitor's item can arrive without its video, so
+ * test each one with `viralItemHasVideo` before a video player.
+ */
+export type ViralItem = ViralMindsItem | ViralSocialItem;
+/**
+ * Whether the item's own card carries a playable video. Use it on a `media: 'video'` read before a Watch-style
+ * player: a visitor's read can serve an item whose video the server withheld (its card's `media` is then empty).
+ * A video only in a quoted post does not count, as the server never counts a quote's media.
+ */
+export declare function viralItemHasVideo(item: ViralItem): boolean;
+/** A network's trailing pace that velocity is measured against. */
+export interface ViralBaseline {
+    median: number;
+    p90: number;
+    n: number;
+    source: 'trailing' | 'tick' | 'prior';
+}
+export interface ViralProvider {
+    name: string;
+    ok: boolean;
+    lastOkAt: string | null;
+    observedAt: string;
+}
+export interface ViralReadMeta {
+    network: ViralNetwork;
+    category_filter: {
+        selected: string;
+    } | null;
+    media_filter: 'video' | null;
+    /** Null unless the read named a filtering `compass`: what Hide politics left out (sides and Mix are not applied here). */
+    compass_filter: CompassFilterMeta | null;
+    safety_filter: {
+        withheld: number;
+        pending: number;
+    };
+}
+export interface ViralReadResponse {
+    items: ViralItem[];
+    /** Pass as `cursor` for the next page; null at the end of this build's list. */
+    cursor: string | null;
+    builtAt: string | null;
+    status: ViralReadStatus;
+    window: {
+        primary: '1h';
+        context: '6h';
+    };
+    baselines: Record<string, ViralBaseline>;
+    provenance: {
+        providers: ViralProvider[];
+    };
+    meta: ViralReadMeta;
+    /** True when no further page exists in this build (always on `off` and `building`). */
+    exhausted: boolean;
+}
 /** Read options for callers that hold their own deadline, such as a discovery page. */
 export interface SocialReadOptions {
     retry?: boolean;
@@ -1302,6 +1513,13 @@ export interface SocialConversation {
     replies: SocialPost[];
     coverage: 'public_provider_window';
     limited: boolean;
+    /**
+     * The member hid this post, or blocks or mutes its author: `focus` is the post, so the app can show it on request,
+     * `replies` is empty, and `viewerControls` are the member's controls to undo. Absent otherwise (a post the app's
+     * moderation withholds is `post_unavailable`).
+     */
+    hiddenByViewer?: true;
+    viewerControls?: Array<Pick<SocialSourceControl, 'source' | 'control'>>;
 }
 export interface SocialFollowingSource {
     subscriptionId: string;
@@ -1384,6 +1602,14 @@ export declare class ProtocolsResource {
     getSharedRadarStory(projectId: string, params: {
         cluster: string;
     }): Promise<SingleResponse<SocialRadarStory>>;
+    /**
+     * The Viral read without a key, for a signed-out visitor: posts whose authors allow wide reach only, and media only
+     * where the server cleared it, so a `media: 'video'` read can carry items whose video was withheld (filter with
+     * `viralItemHasVideo`). `status: 'off'` (no items, never thrown) until the server enables the read for the app;
+     * an API that predates the read answers this path 401 `missing_api_key`, which resolves as off too. Every other
+     * failure throws. Cacheable for a minute by a shared cache.
+     */
+    getSharedViral(projectId: string, params?: ViralReadParams, options?: SocialReadOptions): Promise<SingleResponse<ViralReadResponse>>;
     publicNetworks(): Promise<SingleResponse<SocialNetwork[]>>;
     /** Query the live public network. It does not import users or posts. */
     searchPublicPosts(params: SearchPublicPostsParams): Promise<SingleResponse<SocialPostSearch>>;
@@ -1452,6 +1678,12 @@ export declare class ProtocolsResource {
     getPublicRadarStory(params: {
         cluster: string;
     }, options?: SocialReadOptions): Promise<SingleResponse<SocialRadarStory>>;
+    /**
+     * The Viral read under the signed-in member's app key (scopes `users:read` and `posts:read`): every network's posts
+     * the build keeps, less the member's own blocks, mutes and hidden posts. Never cached. `status: 'off'` resolves with
+     * no items; a 401 or 403 always throws (a session or key failure is never reported as off).
+     */
+    getPublicViral(params?: ViralReadParams, options?: SocialReadOptions): Promise<SingleResponse<ViralReadResponse>>;
     /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
     getPublicPopularProfiles(params: {
         protocol: string;

package/dist/resources/protocols.js

@@ -1,4 +1,4 @@
-import { ValidationError } from '../errors.js';
+import { AuthenticationError, ValidationError } from '../errors.js';
 /** Canonical protocol operation names returned by the adapter registry. */
 export const PROTOCOL_CAPABILITY_OPERATIONS = Object.freeze([
     'discover',
@@ -34,12 +34,43 @@ function hostedIdentityPath(id) {
     }
     return `/protocols/identities/${encodeURIComponent(id)}`;
 }
+/**
+ * Whether the item's own card carries a playable video. Use it on a `media: 'video'` read before a Watch-style
+ * player: a visitor's read can serve an item whose video the server withheld (its card's `media` is then empty).
+ * A video only in a quoted post does not count, as the server never counts a quote's media.
+ */
+export function viralItemHasVideo(item) {
+    return item.post.media.some(media => media.type === 'video');
+}
 /** Only the two radar fields travel; caller scope or destination extras never reach the query string. */
 /** Forwarded only when given, so a default read makes exactly the call it always made. */
 const readOptions = (options) => options ? [options] : [];
 function radarQuery(params) {
     return { ...(params.category !== undefined ? { category: params.category } : {}), ...(params.limit !== undefined ? { limit: params.limit } : {}) };
 }
+/** Only the six Viral read fields travel, each only when given: the read answers any other parameter with a 400. */
+function viralQuery(params) {
+    const query = {};
+    for (const key of ['network', 'category', 'media', 'limit', 'cursor', 'compass'])
+        if (params[key] !== undefined)
+            query[key] = params[key];
+    return query;
+}
+/** An off read is empty whatever else its body carried. Every other status is passed through as served. */
+function viralRead(response) {
+    if (response.data?.status !== 'off')
+        return response;
+    return { ...response, data: { ...response.data, items: [], cursor: null, exhausted: true } };
+}
+/** The server's own off answer (ViralReadService), built here for an API that predates the read. */
+function viralOff(params) {
+    return { data: {
+            items: [], cursor: null, builtAt: null, status: 'off', window: { primary: '1h', context: '6h' }, baselines: {}, provenance: { providers: [] },
+            meta: { network: params.network ?? 'all', category_filter: params.category !== undefined ? { selected: params.category } : null,
+                media_filter: params.media ?? null, compass_filter: null, safety_filter: { withheld: 0, pending: 0 } },
+            exhausted: true,
+        } };
+}
 /** Forward only the media contract fields; nothing else from the app's own media rows. */
 const nativeMediaInput = (media) => media.map(item => ({ url: item.url,
     ...(item.alt !== undefined ? { alt: item.alt } : {}), ...(item.width !== undefined ? { width: item.width } : {}),
@@ -117,6 +148,23 @@ export class ProtocolsResource {
     getSharedRadarStory(projectId, params) {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/radar/story`, { cluster: params.cluster });
     }
+    /**
+     * The Viral read without a key, for a signed-out visitor: posts whose authors allow wide reach only, and media only
+     * where the server cleared it, so a `media: 'video'` read can carry items whose video was withheld (filter with
+     * `viralItemHasVideo`). `status: 'off'` (no items, never thrown) until the server enables the read for the app;
+     * an API that predates the read answers this path 401 `missing_api_key`, which resolves as off too. Every other
+     * failure throws. Cacheable for a minute by a shared cache.
+     */
+    async getSharedViral(projectId, params = {}, options) {
+        try {
+            return viralRead(await this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/viral`, viralQuery(params), ...readOptions(options)));
+        }
+        catch (error) {
+            if (error instanceof AuthenticationError && error.code === 'missing_api_key')
+                return viralOff(params);
+            throw error;
+        }
+    }
     publicNetworks() {
         return this.client.get('/protocols/social/networks');
     }
@@ -188,6 +236,14 @@ export class ProtocolsResource {
     getPublicRadarStory(params, options) {
         return this.client.get('/protocols/social/radar/story', { cluster: params.cluster }, ...readOptions(options));
     }
+    /**
+     * The Viral read under the signed-in member's app key (scopes `users:read` and `posts:read`): every network's posts
+     * the build keeps, less the member's own blocks, mutes and hidden posts. Never cached. `status: 'off'` resolves with
+     * no items; a 401 or 403 always throws (a session or key failure is never reported as off).
+     */
+    async getPublicViral(params = {}, options) {
+        return viralRead(await this.client.get('/protocols/social/viral', viralQuery(params), ...readOptions(options)));
+    }
     /** Provider-ranked public accounts with explicit provenance; served from the app's index when a fresh snapshot exists. */
     getPublicPopularProfiles(params) {
         return this.client.get('/protocols/social/popular-profiles', { protocol: params.protocol, limit: params.limit, cursor: params.cursor });

package/dist/resources/search.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { Post } from '../types.js';
+import type { Post, ViewerModeration } from '../types.js';
 import type { SocialPost } from './protocols.js';
 /** The sections a blended search can answer, in no particular order (see `SearchAnswer.order`). */
 export declare const SEARCH_SECTIONS: readonly ["top_posts", "latest_posts", "open_network", "people", "groups", "topics", "stories", "related", "trending"];
@@ -34,6 +34,14 @@ export interface SearchPerson {
     plus: boolean;
     pro: boolean;
     founder: boolean;
+    /**
+     * The account wears the display name of a verified or founder account it is not: it is listed after every account
+     * that is not such a copy. Label it as not the account at `name_matches_verified_handle`. Absent from an older API.
+     */
+    name_matches_verified?: boolean;
+    name_matches_verified_handle?: string | null;
+    /** Whether the caller mutes this account (people search never lists an account in a block with the caller). */
+    viewer?: ViewerModeration;
 }
 export interface SearchGroup {
     id: string;

package/dist/types.d.ts

@@ -54,8 +54,41 @@ export type FalloverStep = {
 } | {
     kind: 'all';
 };
+/**
+ * What a Politics choice (`compass`) did to a page, on the feeds that take one (`posts.list` on discovery, category
+ * and Minds' own lists, `curator.forYou`). Counts only: never a post's placement, never the cells asked for.
+ * `unavailable` means nothing was applied (the filter is not served to this caller yet, or the judgments are not
+ * there). Under Choose sides every post counts once as kept or left out; `non_political`, `pending` and `unplaced`
+ * (with posts judged maybe) are the not-placed rest. `mix` is Mix sides' band counts over the page served.
+ */
+export interface CompassFilterMeta {
+    status: 'applied' | 'unavailable';
+    mode: 'all' | 'mix' | 'hide' | 'cells';
+    kept: number;
+    left_out: number;
+    unplaced: number;
+    pending: number;
+    non_political: number;
+    uncertain_shown: number;
+    truncated: boolean;
+    rubric?: string;
+    mix?: {
+        econ: {
+            l: number;
+            c: number;
+            r: number;
+        };
+        power: {
+            l: number;
+            m: number;
+            o: number;
+        };
+    };
+}
 export interface PaginationMeta {
     discovery?: DiscoveryLayout;
+    /** Present when the request named `compass`: what the Politics choice did to this page. */
+    compass_filter?: CompassFilterMeta;
     scanned?: number;
     category_filter?: {
         selected: string;
@@ -118,6 +151,12 @@ export interface UserSummary {
     username: string;
     image: string | null;
     is_ai: boolean;
+    /**
+     * The account labels itself adult by its own handle, display name or bio:
+     * cover its avatar unless the member turned Show NSFW on. Absent from
+     * servers older than this field and from reads that do not label accounts.
+     */
+    is_nsfw?: boolean;
 }
 export interface User extends UserSummary {
     bio: string | null;
@@ -254,11 +293,24 @@ export interface RepostedPost {
     media: MediaItem[];
     created_at: string;
 }
+/**
+ * What the signed-in caller has done about an account: they block it, they mute it. Never what the account did about
+ * the caller. Absent when the server could not read it, and from an older API.
+ */
+export interface ViewerModeration {
+    blocking: boolean;
+    muting: boolean;
+}
 export interface PostDetail extends Post {
     /** The newest replies (at most 50). */
     replies: PostReply[];
     /** Present when the thread has more replies; pass it to `posts.replies(id, { cursor })` for the next, older page. */
     replies_next_cursor?: string | null;
+    /**
+     * Whether the caller blocks or mutes the author, so a page can say "You blocked @x" (with View and Unblock) instead
+     * of offering a reply or a vote: reacting to or replying to a post across a block answers 403.
+     */
+    viewer?: ViewerModeration;
 }
 export interface PostReply {
     id: string;
@@ -329,6 +381,21 @@ export interface ListPostsParams extends PaginationParams {
     discovery?: boolean;
     /** Public-only broad category. Requires an enabled app experiment; limit <=25. */
     category?: string;
+    /**
+     * A Politics choice on a discovery, category or Minds list read: `all`, `mix`, `hide`, or cells in the canonical
+     * order `lo,co,ro,lm,cm,rm,ll,cl,rl`, optionally followed by `np`. Any other spelling is 400 `invalid_compass`; on a
+     * profile, group, Following, liked or saved read it is 400 `compass_not_supported`. Mix sides and Choose sides
+     * spend the member's hourly budget (429 `compass_rate_limited`). The page says what it did in
+     * `meta.compass_filter`. Only Minds posts are filtered.
+     */
+    compass?: string;
+    /**
+     * `false` asks once: the first 5xx or 429 is thrown, with no retry and no Retry-After sleep. For a read that holds its
+     * own deadline, such as a Discover feed session's Minds read. Never sent to the server. It rides in the params, not
+     * in a second argument, so a reader wrapped by a function that forwards only its params (as the Minds app wraps the
+     * `posts.list` it hands a feed session, to add a Politics choice) still asks once.
+     */
+    retry?: boolean;
     community_id?: string;
     author_id?: string;
     organization_id?: string;
@@ -336,6 +403,8 @@ export interface ListPostsParams extends PaginationParams {
     tag_ids?: string;
     /** Pass 'me' to return only posts where audience_user_id matches the caller (personal agent feed). */
     audience_user_id?: 'me' | string;
+    /** Return only posts by accounts the authenticated caller follows, newest first (the Following feed). */
+    following?: boolean;
     /** Return only posts the authenticated caller has upvoted. */
     liked?: boolean;
     /**
@@ -514,6 +583,12 @@ export interface CommunityMember {
     image: string | null;
     bio: string | null;
     is_ai: boolean;
+    /**
+     * The account labels itself adult by its own handle, display name or bio:
+     * cover its avatar unless the member turned Show NSFW on. Absent from
+     * servers older than this field and from reads that do not label accounts.
+     */
+    is_nsfw?: boolean;
     role: string;
     joined_at: string;
 }
@@ -1017,6 +1092,12 @@ export interface Profile {
     location: string | null;
     website: string | null;
     is_ai: boolean;
+    /**
+     * The account labels itself adult by its own handle, display name or bio:
+     * cover its avatar unless the member turned Show NSFW on. Absent from
+     * servers older than this field and from reads that do not label accounts.
+     */
+    is_nsfw?: boolean;
     created_at: string;
 }
 /** A row of a followers/following list: the profile plus the caller's relationship with it. */
@@ -1086,6 +1167,14 @@ export interface ProfileSearchResult extends Profile {
     plus: boolean;
     pro: boolean;
     founder: boolean;
+    /**
+     * The account wears the display name of a verified or founder account it is not: it is listed after every account
+     * that is not such a copy. Label it as not the account at `name_matches_verified_handle`. Absent from an older API.
+     */
+    name_matches_verified?: boolean;
+    name_matches_verified_handle?: string | null;
+    /** Whether the caller mutes this account (a search never lists an account in a block with the caller). */
+    viewer?: ViewerModeration;
 }
 export interface SearchMentionsParams {
     /** What the member typed after `@` (a leading `@` is ignored). */