@recursiv/sdk 0.7.44 → 0.7.46

package/dist/resources/discovery-learning.d.ts

@@ -1,6 +1,6 @@
 import type { DiscoveryLayout } from '../types.js';
-/** Layout presentations plus the recommendation module kinds, so viewers who keep hiding a kind stop seeing it. */
-export type DiscoveryPresentation = DiscoveryLayout['presentation'] | 'groups' | 'people' | 'tags';
+/** Layout presentations plus the recommendation and radar module kinds, so viewers who keep hiding a kind stop seeing it. */
+export type DiscoveryPresentation = DiscoveryLayout['presentation'] | 'groups' | 'people' | 'tags' | 'breaking' | 'story';
 type Counts = {
     views: number;
     engagements: number;

package/dist/resources/discovery-learning.js

@@ -1,8 +1,9 @@
-const names = ['posts', 'visual', 'conversation', 'video', 'thread', 'longread', 'groups', 'people', 'tags'];
+const names = ['posts', 'visual', 'conversation', 'video', 'thread', 'longread', 'groups', 'people', 'tags', 'breaking', 'story'];
 const fresh = (now) => ({ version: 1, startedAt: now, layouts: {
         video: { views: 0, engagements: 0, hides: 0 }, posts: { views: 0, engagements: 0, hides: 0 }, visual: { views: 0, engagements: 0, hides: 0 }, conversation: { views: 0, engagements: 0, hides: 0 },
         thread: { views: 0, engagements: 0, hides: 0 }, longread: { views: 0, engagements: 0, hides: 0 },
         groups: { views: 0, engagements: 0, hides: 0 }, people: { views: 0, engagements: 0, hides: 0 }, tags: { views: 0, engagements: 0, hides: 0 },
+        breaking: { views: 0, engagements: 0, hides: 0 }, story: { views: 0, engagements: 0, hides: 0 },
     } });
 /** Local, per-viewer experimental presentation preferences. Stores counts only,
  * never source text, author IDs or inferred traits. It cannot promote content,

package/dist/resources/discovery.d.ts

@@ -1,7 +1,7 @@
-import type { DiscoveryLearning } from './discovery-learning.js';
 import type { DiscoveryLayout, Post } from '../types.js';
+import type { DiscoveryLearning } from './discovery-learning.js';
 import type { PostsResource } from './posts.js';
-import type { ProtocolsResource, SocialNetwork, SocialPost } from './protocols.js';
+import type { ProtocolsResource, SocialNetwork, SocialPost, SocialRadar } from './protocols.js';
 export type DiscoveryRecommendationKind = 'groups' | 'people' | 'tags';
 export interface DiscoveryGroupCandidate {
     id: string;
@@ -38,6 +38,51 @@ export interface DiscoveryRecommendationSources {
     people?: () => Promise<DiscoveryPersonCandidate[]>;
     tags?: () => Promise<DiscoveryTagCandidate[]>;
 }
+/** An outlet or Hacker News member of a radar cluster: rendered as a link chip, never as a post card. */
+export interface DiscoveryClusterSource {
+    kind: 'outlet' | 'hackernews';
+    title: string;
+    url: string;
+    outlet?: string;
+    lane?: 'mainstream' | 'independent';
+    publishedAt: string;
+}
+/** One story from the app's topic radar, validated for rendering. Every value is a reference to server data; the label is a verbatim headline or topic name. */
+export interface DiscoveryCluster {
+    id: string;
+    label: string;
+    kind: 'breaking' | 'viral' | 'story';
+    theme?: string;
+    outletCount: number;
+    laneMix: {
+        mainstream: number;
+        independent: number;
+    };
+    sources: Record<string, number>;
+    velocity: {
+        normalized: number;
+    };
+    newestAt: string;
+    lead?: {
+        type: 'image' | 'video';
+        url: string;
+        poster?: string;
+        width?: number;
+        height?: number;
+        memberKey: string;
+    };
+    links: DiscoveryClusterSource[];
+    /** Keys of the minds/social DiscoveryPostItems that belong to the story, in this session's key format. */
+    memberKeys: string[];
+}
+/** Reader for the app's radar snapshot; bounded to three seconds and optional, so an older server simply yields no radar module. */
+export type DiscoveryRadarSource = (params: {
+    limit?: number;
+    category?: string;
+}) => Promise<{
+    data: SocialRadar;
+}>;
+export type DiscoveryRadarPresentation = 'breaking' | 'story';
 export type DiscoveryPostItem = {
     key: string;
     kind: 'minds';
@@ -59,15 +104,21 @@ export type DiscoveryItem = DiscoveryPostItem | {
     key: string;
     kind: 'tag';
     tag: DiscoveryTagCandidate;
+} | {
+    key: string;
+    kind: 'cluster';
+    cluster: DiscoveryCluster;
 };
 export declare const isDiscoveryPost: (item: DiscoveryItem) => item is DiscoveryPostItem;
 /** At most this many candidates per recommendation module. */
 export declare const RECOMMENDATION_MAX_ITEMS = 6;
+/** Clusters read from the radar per session; the server never holds more. */
+export declare const RADAR_MAX_CLUSTERS = 40;
 /** json-render Spec: values are references to authenticated SDK results, never
  * arbitrary executable components, links, generated text or provider markup. */
 export interface DiscoveryModule {
     id: string;
-    presentation: DiscoveryLayout['presentation'] | DiscoveryRecommendationKind;
+    presentation: DiscoveryLayout['presentation'] | DiscoveryRecommendationKind | DiscoveryRadarPresentation;
     source: DiscoveryLayout['source'];
     /** Subject of the featured window (a browse-category id or `mixed`), for specific module copy. */
     theme?: string;
@@ -76,7 +127,7 @@ export interface DiscoveryModule {
         root: 'module';
         elements: {
             module: {
-                type: 'DiscoveryPosts' | 'DiscoveryGallery' | 'DiscoveryConversation' | 'DiscoveryVideo' | 'DiscoveryThread' | 'DiscoveryLongRead' | 'DiscoveryGroups' | 'DiscoveryPeople' | 'DiscoveryTags';
+                type: 'DiscoveryPosts' | 'DiscoveryGallery' | 'DiscoveryConversation' | 'DiscoveryVideo' | 'DiscoveryThread' | 'DiscoveryLongRead' | 'DiscoveryGroups' | 'DiscoveryPeople' | 'DiscoveryTags' | 'DiscoveryBreaking' | 'DiscoveryStory';
                 props: {
                     itemKeys: string[];
                 };
@@ -107,11 +158,19 @@ export declare class DiscoveryFeedSession {
     private seen;
     private page;
     private nextSource;
-    constructor(posts: Pick<PostsResource, 'list'>, protocols: Pick<ProtocolsResource, 'getPublicTrends' | 'getPublicTrendFeed'>, networks: SocialNetwork[], category?: string | undefined, source?: string, learning?: DiscoveryLearning | undefined, recommend?: DiscoveryRecommendationSources | undefined);
+    /** The radar snapshot, read once on the first page; null until then. */
+    private clusters;
+    private radarUsed;
+    private radar?;
+    constructor(posts: Pick<PostsResource, 'list'>, protocols: Pick<ProtocolsResource, 'getPublicTrends' | 'getPublicTrendFeed'>, networks: SocialNetwork[], category?: string | undefined, source?: string, learning?: DiscoveryLearning | undefined, recommend?: DiscoveryRecommendationSources | undefined, radar?: DiscoveryRadarSource);
     retryFailed(): void;
     next(): Promise<DiscoveryFeedPage>;
     private read;
     private readPage;
+    /** Page 0: the top breaking cluster, else the top cluster. Every second later page: the next unused story or viral cluster. */
+    private radarCluster;
+    private loadRadar;
+    private radarModule;
     private recommendation;
 }
 export declare class DiscoveryResource {

package/dist/resources/discovery.js

@@ -1,6 +1,9 @@
 export const isDiscoveryPost = (item) => item.kind === 'minds' || item.kind === 'social';
 /** At most this many candidates per recommendation module. */
 export const RECOMMENDATION_MAX_ITEMS = 6;
+/** Clusters read from the radar per session; the server never holds more. */
+export const RADAR_MAX_CLUSTERS = 40;
+const RADAR_MAX_MEMBERS = 12;
 const RECOMMENDATION_KINDS = ['groups', 'people', 'tags'];
 const nonEmpty = (value) => typeof value === 'string' && value.trim().length > 0 && value.length <= 512;
 function recommendationItem(kind, candidate) {
@@ -21,6 +24,75 @@ function recommendationItem(kind, candidate) {
         return null;
     return { key: `rec:tag:${(nonEmpty(value.slug) ? value.slug : value.name).toLowerCase()}`, kind: 'tag', tag: value };
 }
+const RADAR_KINDS = new Set(['breaking', 'viral', 'story']);
+const RADAR_SOCIAL_KINDS = new Set(['bluesky', 'activitypub', 'nostr']);
+const httpUrl = (value) => typeof value === 'string' && value.length <= 4096 && /^https?:\/\//i.test(value);
+const countOf = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : null;
+const dimension = (value) => typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+/** Validate one radar cluster: bad or unexpected shapes are dropped, never rendered. Member keys are translated to this session's key format. */
+function radarCluster(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const c = value;
+    if (typeof c.id !== 'string' || !/^[0-9a-f]{64}$/.test(c.id) || !nonEmpty(c.label) || typeof c.kind !== 'string' || !RADAR_KINDS.has(c.kind))
+        return null;
+    const newestAt = (c.freshness ?? {}).newestAt;
+    if (typeof newestAt !== 'string' || !Number.isFinite(Date.parse(newestAt)))
+        return null;
+    const laneMix = (c.laneMix ?? {});
+    const mainstream = countOf(laneMix.mainstream);
+    const independent = countOf(laneMix.independent);
+    if (mainstream === null || independent === null)
+        return null;
+    const normalized = c.velocity?.normalized;
+    const sources = {};
+    if (c.sources && typeof c.sources === 'object')
+        for (const [name, count] of Object.entries(c.sources)) {
+            const n = countOf(count);
+            if (n !== null && /^[a-z]{1,32}$/.test(name))
+                sources[name] = n;
+        }
+    const links = [];
+    const memberKeys = [];
+    const translated = new Map();
+    for (const raw of Array.isArray(c.members) ? c.members.slice(0, RADAR_MAX_MEMBERS) : []) {
+        if (!raw || typeof raw !== 'object')
+            continue;
+        const member = raw;
+        if (typeof member.key !== 'string' || !member.key || member.key.length > 4096)
+            continue;
+        if (member.kind === 'outlet' || member.kind === 'hackernews') {
+            if (!nonEmpty(member.title) || !httpUrl(member.url) || typeof member.publishedAt !== 'string')
+                continue;
+            const outlet = (member.outlet ?? {});
+            links.push({ kind: member.kind, title: member.title, url: member.url, ...(nonEmpty(outlet.name) ? { outlet: outlet.name } : {}),
+                ...(outlet.lane === 'mainstream' || outlet.lane === 'independent' ? { lane: outlet.lane } : {}), publishedAt: member.publishedAt });
+            continue;
+        }
+        let itemKey = null;
+        if (member.kind === 'minds')
+            itemKey = key('minds', member.key);
+        else if (typeof member.kind === 'string' && RADAR_SOCIAL_KINDS.has(member.kind)) {
+            try {
+                const parsed = JSON.parse(member.key);
+                if (Array.isArray(parsed) && parsed.length === 2 && parsed[0] === member.kind && nonEmpty(parsed[1]))
+                    itemKey = key(parsed[0], parsed[1]);
+            }
+            catch { /* not a post reference */ }
+        }
+        if (itemKey && !memberKeys.includes(itemKey)) {
+            memberKeys.push(itemKey);
+            translated.set(member.key, itemKey);
+        }
+    }
+    const media = (c.media?.lead ?? null);
+    const lead = media && (media.type === 'image' || media.type === 'video') && httpUrl(media.url) && typeof media.memberKey === 'string' && media.memberKey
+        ? { type: media.type, url: media.url, ...(httpUrl(media.poster) ? { poster: media.poster } : {}), ...(dimension(media.width) && dimension(media.height) ? { width: dimension(media.width), height: dimension(media.height) } : {}),
+            memberKey: translated.get(media.memberKey) ?? media.memberKey } : undefined;
+    const theme = typeof c.theme === 'string' && /^[a-z][a-z0-9-]{0,31}$/.test(c.theme) ? c.theme : undefined;
+    return { id: c.id, label: c.label.slice(0, 300), kind: c.kind, ...(theme ? { theme } : {}), outletCount: mainstream + independent, laneMix: { mainstream, independent }, sources,
+        velocity: { normalized: typeof normalized === 'number' && Number.isFinite(normalized) && normalized >= 0 ? normalized : 0 }, newestAt, ...(lead ? { lead } : {}), links, memberKeys };
+}
 const ordinary = { version: 'discovery-layout-v1', presentation: 'posts', source: 'fallback' };
 const key = (protocol, id) => JSON.stringify([protocol, id]);
 const presentations = new Set(['posts', 'visual', 'conversation', 'video', 'thread', 'longread']);
@@ -52,12 +124,19 @@ export class DiscoveryFeedSession {
     seen = new Set();
     page = 0;
     nextSource = 0;
-    constructor(posts, protocols, networks, category, source, learning, recommend) {
+    /** The radar snapshot, read once on the first page; null until then. */
+    clusters = null;
+    radarUsed = new Set();
+    radar;
+    constructor(posts, protocols, networks, category, source, learning, recommend, radar) {
         this.posts = posts;
         this.protocols = protocols;
         this.category = category;
         this.learning = learning;
         this.recommend = recommend;
+        // The radar clusters across every source, so a feed narrowed to one network carries none.
+        if (!source || source === 'all')
+            this.radar = radar;
         const sources = [...new Set(networks.filter(n => n.capabilities.includes('public_trends')).map(n => n.protocol))].slice(0, 16);
         this.streams = ['minds', ...sources].filter(protocol => !source || source === 'all' || source === protocol)
             .map(protocol => ({ protocol, offset: 0, done: false, failed: false, used: [] }));
@@ -73,7 +152,9 @@ export class DiscoveryFeedSession {
     async read(stream) {
         const params = { limit: 25, ...(this.category ? { category: this.category } : {}), discovery: true };
         if (stream.protocol === 'minds') {
-            const response = await this.posts.list({ ...params, sort: 'new', ...(stream.cursor ? { cursor: stream.cursor } : { offset: stream.offset }) });
+            // Discover leads with what is moving now: the REST hot order (engagement
+            // decayed by age). Hot pages by offset; the server sends no cursor for it.
+            const response = await this.posts.list({ ...params, sort: 'hot', ...(stream.cursor ? { cursor: stream.cursor } : { offset: stream.offset }) });
             stream.offset += response.meta.scanned ?? response.meta.limit;
             const next = response.meta.next_cursor ?? undefined;
             stream.done = !response.meta.has_more || !!next && (next === stream.cursor || stream.used.includes(next));
@@ -167,6 +248,19 @@ export class DiscoveryFeedSession {
         const modules = [];
         const page = this.page++;
         let remaining = mixed;
+        // The radar leads the first page with the top breaking story and returns
+        // every second page with the next one. Its member posts move under the
+        // story, on this page or on any later one, so the hot stream never repeats them.
+        const cluster = mixed.length ? await this.radarCluster(page) : null;
+        let clusterItems = [];
+        if (cluster) {
+            const members = new Set(cluster.memberKeys);
+            // Under the story, posts keep the server's member order: the lead media member first, then by member score.
+            clusterItems = remaining.filter(row => members.has(row.item.key)).map(row => row.item).sort((a, b) => cluster.memberKeys.indexOf(a.key) - cluster.memberKeys.indexOf(b.key));
+            remaining = remaining.filter(row => !members.has(row.item.key));
+            for (const memberKey of cluster.memberKeys)
+                this.seen.add(memberKey);
+        }
         // One gallery strip per page: it may gather images from the whole page, so a
         // second one would only sweep up leftovers into a stub.
         let galleryMinted = false;
@@ -206,9 +300,64 @@ export class DiscoveryFeedSession {
         const recommendation = modules.length ? await this.recommendation(page) : null;
         if (recommendation)
             modules.splice(Math.min(2, modules.length), 0, recommendation);
+        if (cluster)
+            modules.splice(page === 0 ? 0 : Math.min(2, modules.length), 0, this.radarModule(page, cluster, clusterItems));
         return { modules, hasMore: this.streams.some(stream => !stream.done && !stream.failed),
             failedSources: this.streams.filter(stream => stream.failed).map(stream => stream.protocol), partialCategories: reads.some(read => read.partial) };
     }
+    /** Page 0: the top breaking cluster, else the top cluster. Every second later page: the next unused story or viral cluster. */
+    async radarCluster(page) {
+        if (!this.radar)
+            return null;
+        if (page === 0)
+            this.clusters = await this.loadRadar();
+        if (!this.clusters?.length || (page !== 0 && page % 2 !== 0))
+            return null;
+        const unused = this.clusters.filter(candidate => !this.radarUsed.has(candidate.id));
+        const cluster = page === 0 ? unused.find(candidate => candidate.kind === 'breaking') ?? unused[0] : unused.find(candidate => candidate.kind !== 'breaking');
+        if (!cluster)
+            return null;
+        this.radarUsed.add(cluster.id);
+        // A viewer who keeps hiding radar stories stops seeing them, through the same bandit as layouts.
+        if (this.learning && this.learning.choose(cluster.kind === 'breaking' ? 'breaking' : 'story', page) === 'posts')
+            return null;
+        return cluster;
+    }
+    async loadRadar() {
+        let response;
+        let cancel = () => { };
+        try {
+            response = await Promise.race([this.radar({ limit: RADAR_MAX_CLUSTERS, ...(this.category ? { category: this.category } : {}) }), new Promise((_resolve, reject) => {
+                    const timer = setTimeout(() => reject(new Error('Radar source timed out')), 3000);
+                    cancel = () => clearTimeout(timer);
+                })]);
+        }
+        catch {
+            return [];
+        }
+        finally {
+            cancel();
+        }
+        const clusters = response?.data?.clusters;
+        if (!Array.isArray(clusters))
+            return [];
+        const out = [];
+        const ids = new Set();
+        for (const value of clusters.slice(0, RADAR_MAX_CLUSTERS)) {
+            const cluster = radarCluster(value);
+            if (cluster && !ids.has(cluster.id)) {
+                ids.add(cluster.id);
+                out.push(cluster);
+            }
+        }
+        return out;
+    }
+    radarModule(page, cluster, posts) {
+        const presentation = cluster.kind === 'breaking' ? 'breaking' : 'story';
+        const items = [{ key: `radar:${cluster.id}`, kind: 'cluster', cluster }, ...posts];
+        return { id: `discovery-${page}-radar-${cluster.id}`, presentation, source: 'fallback', items, ...(cluster.theme && cluster.theme !== 'mixed' ? { theme: cluster.theme } : {}),
+            spec: { root: 'module', elements: { module: { type: presentation === 'breaking' ? 'DiscoveryBreaking' : 'DiscoveryStory', props: { itemKeys: items.map(item => item.key) }, children: [] } } } };
+    }
     async recommendation(page) {
         const kinds = RECOMMENDATION_KINDS.filter(kind => typeof this.recommend?.[kind] === 'function');
         const kind = kinds[page % Math.max(1, kinds.length)];
@@ -259,6 +408,7 @@ export class DiscoveryResource {
         this.protocols = protocols;
     }
     createFeed(options) {
-        return new DiscoveryFeedSession(this.posts, this.protocols, options.networks, options.category, options.source, options.learning, options.recommend);
+        // The radar rides along by default; an older server answers 404 and the session simply shows no story module.
+        return new DiscoveryFeedSession(this.posts, this.protocols, options.networks, options.category, options.source, options.learning, options.recommend, params => this.protocols.getPublicRadar(params));
     }
 }

package/dist/resources/protocols.d.ts

@@ -1,6 +1,5 @@
-import type { DiscoveryLayout } from '../types.js';
 import type { HttpClient } from '../client.js';
-import type { PaginatedResponse, PaginationParams, SingleResponse } from '../types.js';
+import type { 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"];
@@ -844,11 +843,14 @@ export interface SocialPost {
     replyCount: number | null;
     likeCount: number | null;
     repostCount: number | null;
+    /** 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. */
     media: Array<{
         type: 'image' | 'video';
         url: string;
         alt: string;
         poster?: string;
+        width?: number;
+        height?: number;
     }>;
     hasAdditionalContent: boolean;
     /** At most one independently filtered quoted post. */
@@ -927,6 +929,103 @@ export interface SocialTrendFeed extends SocialTrendProvenance {
     items: SocialPost[];
     cursor: string | null;
 }
+/** A member of a radar cluster: a headline or excerpt and a link only, never a body. */
+export type SocialRadarSourceKind = 'outlet' | 'hackernews' | 'bluesky' | 'activitypub' | 'nostr' | 'minds';
+export interface SocialRadarMember {
+    kind: SocialRadarSourceKind;
+    /** outlet: the article url; hackernews: the `hn:<id>` candidate id; social: JSON `[protocol, nativeId]`; minds: the post id. */
+    key: string;
+    title: string;
+    url?: string;
+    publishedAt: string;
+    outlet?: {
+        name: string;
+        lane: 'mainstream' | 'independent';
+    };
+    engagement?: {
+        likes?: number;
+        reposts?: number;
+        replies?: number;
+        score?: number;
+        perHour?: number;
+        samples: number;
+    };
+    media?: {
+        type: 'image' | 'video';
+        url: string;
+        poster?: string;
+        width?: number;
+        height?: number;
+    };
+    providerRank?: number;
+}
+/** One story on the radar. `breaking` is outlet corroboration inside a short window; `viral` is social velocity above its network's norm. */
+export interface SocialRadarCluster {
+    id: string;
+    /** Verbatim: a World Today headline, a provider topic name or the medoid outlet title. Never generated. */
+    label: string;
+    kind: 'breaking' | 'viral' | 'story';
+    seed: {
+        kind: 'world_story' | 'trend_topic' | 'emergent';
+        ref: string;
+    };
+    /** A browse-category id or `mixed`, from cached judgments only. */
+    theme?: string;
+    sources: Partial<Record<SocialRadarSourceKind, number>>;
+    corroboration: number;
+    laneMix: {
+        mainstream: number;
+        independent: number;
+    };
+    velocity: {
+        perHour: number;
+        normalized: number;
+        samples: number;
+    };
+    media: {
+        images: number;
+        videos: number;
+        lead?: {
+            type: 'image' | 'video';
+            url: string;
+            poster?: string;
+            width?: number;
+            height?: number;
+            memberKey: string;
+        };
+    };
+    freshness: {
+        newestAt: string;
+        oldestAt: string;
+        outletsInBreakingWindow: number;
+    };
+    score: number;
+    members: SocialRadarMember[];
+}
+/** The app's radar snapshot: rebuilt by a server job on its own interval, never on a request. `builtAt` is null before the first tick. */
+export interface SocialRadar {
+    version: 'topic-radar-v1';
+    builtAt: string | null;
+    windowHours: number;
+    breakingWindowHours: number;
+    clusters: SocialRadarCluster[];
+    provenance: {
+        providers: Array<{
+            name: string;
+            observedAt: string;
+            coverage: 'provider_ranked_window' | 'allowlisted_outlets' | 'minds_hot';
+        }>;
+    };
+    /** Present when a category was selected; `partial` while some clusters have no cached theme yet. */
+    radar_filter?: {
+        selected: string;
+        status: 'complete' | 'partial';
+    };
+}
+export interface SocialRadarParams {
+    category?: string;
+    limit?: number;
+}
 /** Provider-ranked accounts. `source` says whether this page is the app's hourly index snapshot or a live read. */
 export interface SocialPopularProfiles {
     items: SocialProfile[];
@@ -1007,6 +1106,8 @@ export declare class ProtocolsResource {
         category?: string;
         discovery?: boolean;
     }): Promise<SingleResponse<SocialTrendFeed>>;
+    /** Breaking and viral stories clustered across outlets, open networks and Minds, through the same public-only app boundary. */
+    getSharedRadar(projectId: string, params?: SocialRadarParams): Promise<SingleResponse<SocialRadar>>;
     publicNetworks(): Promise<SingleResponse<SocialNetwork[]>>;
     /** Query the live public network. It does not import users or posts. */
     searchPublicPosts(params: SearchPublicPostsParams): Promise<SingleResponse<SocialPostSearch>>;
@@ -1056,6 +1157,8 @@ export declare class ProtocolsResource {
         category?: string;
         discovery?: boolean;
     }): Promise<SingleResponse<SocialTrendFeed>>;
+    /** The app's topic radar under its own key: the same snapshot the keyless route serves. Never triggers a build. */
+    getPublicRadar(params?: SocialRadarParams): Promise<SingleResponse<SocialRadar>>;
     /** 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

@@ -34,6 +34,10 @@ function hostedIdentityPath(id) {
     }
     return `/protocols/identities/${encodeURIComponent(id)}`;
 }
+/** Only the two radar fields travel; caller scope or destination extras never reach the query string. */
+function radarQuery(params) {
+    return { ...(params.category !== undefined ? { category: params.category } : {}), ...(params.limit !== undefined ? { limit: params.limit } : {}) };
+}
 export class ProtocolsResource {
     client;
     subscriptionListeners = new Set();
@@ -80,6 +84,10 @@ export class ProtocolsResource {
         return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/trend-feed`, { protocol: params.protocol, topic: params.topic,
             limit: params.limit, cursor: params.cursor, category: params.category, discovery: params.discovery });
     }
+    /** Breaking and viral stories clustered across outlets, open networks and Minds, through the same public-only app boundary. */
+    getSharedRadar(projectId, params = {}) {
+        return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/radar`, radarQuery(params));
+    }
     publicNetworks() {
         return this.client.get('/protocols/social/networks');
     }
@@ -130,6 +138,10 @@ export class ProtocolsResource {
             ...(params.category !== undefined ? { category: params.category } : {}),
             ...(params.discovery !== undefined ? { discovery: params.discovery } : {}) });
     }
+    /** The app's topic radar under its own key: the same snapshot the keyless route serves. Never triggers a build. */
+    getPublicRadar(params = {}) {
+        return this.client.get('/protocols/social/radar', radarQuery(params));
+    }
     /** 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@recursiv/sdk",
-  "version": "0.7.44",
+  "version": "0.7.46",
   "description": "TypeScript SDK for the Recursiv API",
   "license": "FSL-1.1-ALv2",
   "type": "module",