@recursiv/sdk 0.7.69 → 0.7.71

package/dist/resources/judgments.d.ts

@@ -0,0 +1,252 @@
+import type { HttpClient } from '../client.js';
+import { ConflictError } from '../errors.js';
+import type { SingleResponse } from '../types.js';
+/** A Minds post (`post`, its uuid) or an open-network post (`network_post`, its subject id). */
+export type JudgmentSubjectKind = 'post' | 'network_post';
+/** Who wrote the label: Jev (`model`), or staff who overrode it (`review`). */
+export type JudgmentSource = 'model' | 'review';
+/** Whether the server's judgment store answered. `'unavailable'`: only the category index's label is known; hide label actions. */
+export type PostLabelsStatus = 'ok' | 'unavailable';
+/** How an override met its quorum: one reviewer (a safety appeal), two agreeing reviewers, or one beside an agreeing Jev re-judge. */
+export type JudgmentOverrideMethod = 'reviewer' | 'two_reviewers' | 'reviewer_and_rejudge';
+export interface PostLabelsQuery {
+    kind: JudgmentSubjectKind;
+    /** A Minds post id, or an open-network post's subject id. */
+    id: string;
+}
+export interface PostLabelsSubject {
+    kind: JudgmentSubjectKind;
+    id: string;
+}
+export interface PostLabelsCategory {
+    id: string;
+    name: string;
+}
+/** The compass band in words. Never a probability or a cell code. */
+export interface PostLabelsPolitics {
+    /** The judgment a member disputes with `dispute(judgment_id, { question_key: 'placement', proposed })`. */
+    judgment_id: string;
+    politics: 'Takes a side' | 'Maybe' | 'No';
+    /** Each placed axis in words, e.g. `{ axis: 'Liberty ↔ Order', band: 'Order' }`. Empty unless the post takes a side. */
+    axes: Array<{
+        axis: string;
+        band: string;
+    }>;
+    model: string;
+    rubric: string;
+    source: JudgmentSource;
+    judged_at: string | null;
+}
+/** One stored judgment, as the post's author and staff see it. */
+export interface PostJudgmentRecord {
+    id: string;
+    rubric: string;
+    model: string;
+    source: JudgmentSource;
+    judged_at: string | null;
+    /** The typed answers, every probability included. */
+    answers: Record<string, unknown>;
+    political: number | null;
+    cell: string | null;
+    reason: 'hate' | 'spam' | null;
+}
+/** A rubric's current judgment in the full view. */
+export interface PostJudgment extends PostJudgmentRecord {
+    /** How many staff reviewers wrote it (0 for Jev's own). */
+    reviewers: number;
+    /** Staff only. */
+    reviewer_ids?: string[];
+    /** Staff only. */
+    review_note?: string | null;
+    /** Whether `dispute()` takes it: political-compass and safety labels (safety: the author only). */
+    disputable: boolean;
+    /** Jev's judgment a staff review replaced, for the same words. */
+    superseded: PostJudgmentRecord | null;
+}
+/** The safety verdict the Discover floor applies to the post now, with who judged it (full view, Minds posts). */
+export type PostSafetyAttribution = {
+    status: 'judged';
+    reason: 'hate' | 'spam' | null;
+    unsafe: boolean;
+    hate: number;
+    spam: number;
+    rubric: string;
+    /** The judging model, `'review'` for a staff review; null when only the cache holds the verdict. */
+    model: string | null;
+    source: JudgmentSource | 'cache';
+    judgedAt: string | null;
+    /** A staff review the floor does not apply yet (the cache still holds another verdict). */
+    unappliedReview?: {
+        reason: 'hate' | 'spam' | null;
+        unsafe: boolean;
+        hate: number;
+        spam: number;
+        judgedAt: string;
+    };
+} | {
+    status: 'pending';
+} | {
+    status: 'not_judgeable';
+};
+/** A visitor's view (`getPublic`): the category only. */
+export interface PostLabelsCategoryView {
+    subject: PostLabelsSubject;
+    view: 'category';
+    category: PostLabelsCategory | null;
+    status: PostLabelsStatus;
+}
+/** Any other member's view: the category and the compass band in words, with the id to dispute it. */
+export interface PostLabelsSummaryView {
+    subject: PostLabelsSubject;
+    view: 'summary';
+    category: PostLabelsCategory | null;
+    politics: PostLabelsPolitics | null;
+    status: PostLabelsStatus;
+}
+/** The post's author's and staff's view: every rubric's current judgment, the safety verdict and Viral. */
+export interface PostLabelsFullView {
+    subject: PostLabelsSubject;
+    view: 'full';
+    category: PostLabelsCategory | null;
+    politics: PostLabelsPolitics | null;
+    judgments: PostJudgment[];
+    /** null for an open-network post. */
+    safety: PostSafetyAttribution | null;
+    /** Why the post is withheld from Viral ("Withheld from Viral: <reason>"), or null. */
+    viral: {
+        withheld: string | null;
+    };
+    status: PostLabelsStatus;
+}
+/** One post's labels, in the view the caller may see: switch on `view`. */
+export type PostLabels = PostLabelsFullView | PostLabelsSummaryView | PostLabelsCategoryView;
+export interface DisputeJudgmentInput {
+    /** The label's question: `'placement'` for a political-compass label, `'safety'` for a safety label (its author only). */
+    question_key: string;
+    /** The answer it should be: a compass cell (`'lo'`, `'cm'`, …) or `'not_political'`; for safety `'none'`, `'hate'` or `'spam'`. */
+    proposed: string;
+    /** At most 500 characters. */
+    note?: string;
+}
+/** A filed dispute. The author's is an appeal and goes to the moderation queue; anyone else's feeds the evaluation. */
+export interface JudgmentDispute {
+    id: string;
+    judgment_id: string;
+    /** True when the caller wrote the post: an appeal. */
+    appeal: boolean;
+    /** Whether it waits in the moderation queue now. */
+    queued: boolean;
+    /** Present on a repeat: the member's first dispute of this judgment, unchanged. */
+    existing?: true;
+}
+export type ReviewJudgmentInput = {
+    outcome: 'uphold';
+    note?: string;
+} | {
+    outcome: 'override';
+    /** The answer the label becomes. */
+    proposed: string;
+    /** At most 2,000 characters. */
+    note?: string;
+    /** A safety override to `'none'` that frees other posts with exactly these words: send true after a 409 `shared_words`. */
+    apply_to_shared?: boolean;
+};
+/** 200: the label stands, and its queue items are closed. */
+export interface JudgmentReviewUpheld {
+    status: 'upheld';
+    resolved: number;
+}
+/** 202: this reviewer's vote is recorded; a compass label needs another reviewer (or an agreeing Jev re-judge). */
+export interface JudgmentReviewAwaitingReviewer {
+    status: 'awaiting_reviewer';
+    vote_id: string;
+    agreeing: number;
+    needed: number;
+}
+/** 200: the override is written and in the public moderation log. */
+export interface JudgmentReviewOverridden {
+    status: 'overridden';
+    review_id: string;
+    moderation_action_id: string;
+    method: JudgmentOverrideMethod;
+    reviewers: number;
+    resolved: number;
+    trust_log: 'appended' | 'disabled' | 'duplicate';
+    /** A safety review: whether the Discover floor applies it now; null for a compass label. */
+    applied_to_discover: boolean | null;
+    /** A safety review of words the post no longer has: recorded, never applied. */
+    words_changed: boolean | null;
+    shared_posts: number | null;
+}
+export type JudgmentReview = JudgmentReviewUpheld | JudgmentReviewAwaitingReviewer | JudgmentReviewOverridden;
+/** The `details` of a 409 `shared_words` from `review()`. */
+export interface JudgmentSharedWordsDetails {
+    shared_posts: number;
+}
+/** The 409 `review()` throws before a safety override frees other posts with exactly these words. */
+export type JudgmentSharedWordsError = ConflictError & {
+    code: 'shared_words';
+    details: JudgmentSharedWordsDetails;
+};
+/**
+ * Whether `error` is the 409 `shared_words` of `review()`: nothing was recorded, and
+ * `error.details.shared_posts` other posts have exactly these words. Resend with
+ * `apply_to_shared: true` once the reviewer agrees to change them all.
+ */
+export declare function isJudgmentSharedWordsError(error: unknown): error is JudgmentSharedWordsError;
+/**
+ * Jev's labels of one post: read them, dispute or appeal one, and (staff)
+ * decide a dispute.
+ *
+ * Budgets: 60 label reads per member an hour (25 of one author's posts) and
+ * 20 disputes a day. Past one, the server answers 429 with
+ * `X-RateLimit-Scope: action`: the SDK throws `RateLimitError` at once
+ * (`scope === 'action'`, `resetAt`, a member-facing `message`) and never
+ * retries it. Disputes and reviews answer 503 until the server's judgment
+ * store is applied; reads answer `status: 'unavailable'` instead.
+ */
+export declare class JudgmentsResource {
+    private client;
+    constructor(client: HttpClient);
+    /**
+     * One post's labels as the caller may see them. The post's author and staff
+     * get `view: 'full'` (every judgment with its answers, the safety verdict,
+     * Viral); any other member who can see the post gets `view: 'summary'` (the
+     * category and the compass band in words). `status: 'unavailable'` is
+     * returned, not thrown. A post the caller cannot see throws `NotFoundError`.
+     * Open-network posts need a key bound to an app (400 `app_required`).
+     *
+     * @example
+     * const { data } = await r.judgments.get({ kind: 'post', id: postId });
+     * if (data.status === 'ok' && data.view !== 'category' && data.politics) showBand(data.politics);
+     */
+    get(query: PostLabelsQuery): Promise<SingleResponse<PostLabels>>;
+    /**
+     * A signed-out visitor's view of one post's labels: the category only.
+     * Keyless: use an anonymous client (`new Recursiv({ anonymous: true })`).
+     */
+    getPublic(projectId: string, query: PostLabelsQuery): Promise<SingleResponse<PostLabelsCategoryView>>;
+    /**
+     * Disagree with a label. The post's author's dispute is an appeal and goes
+     * to the moderation queue; anyone else's feeds the evaluation and changes
+     * nothing on its own. One per member and judgment: a repeat returns the
+     * first with `existing: true`. Sent once, never retried automatically.
+     *
+     * @example
+     * await r.judgments.dispute(labels.politics.judgment_id, { question_key: 'placement', proposed: 'not_political' });
+     */
+    dispute(judgmentId: string, input: DisputeJudgmentInput): Promise<SingleResponse<JudgmentDispute>>;
+    /**
+     * Staff: uphold a disputed label, or vote to override it. A compass label
+     * changes when two reviewers propose the same answer (or one, beside an
+     * agreeing Jev re-judge): the first gets `status: 'awaiting_reviewer'`
+     * (HTTP 202). Every override is in the public moderation log.
+     *
+     * Sent once, never retried: an override that met its quorum but lost its
+     * response would otherwise be recorded again as a fresh vote. A safety
+     * override to `'none'` that would free other posts with exactly these words
+     * throws a 409 (`isJudgmentSharedWordsError`, `details.shared_posts`) until
+     * resent with `apply_to_shared: true`.
+     */
+    review(judgmentId: string, input: ReviewJudgmentInput): Promise<SingleResponse<JudgmentReview>>;
+}

package/dist/resources/judgments.js

@@ -0,0 +1,79 @@
+import { ConflictError } from '../errors.js';
+/**
+ * Whether `error` is the 409 `shared_words` of `review()`: nothing was recorded, and
+ * `error.details.shared_posts` other posts have exactly these words. Resend with
+ * `apply_to_shared: true` once the reviewer agrees to change them all.
+ */
+export function isJudgmentSharedWordsError(error) {
+    if (!(error instanceof ConflictError) || error.code !== 'shared_words')
+        return false;
+    const count = error.details?.shared_posts;
+    return typeof count === 'number' && Number.isFinite(count);
+}
+const path = (judgmentId, action) => `/content-judgments/${encodeURIComponent(judgmentId)}/${action}`;
+/**
+ * Jev's labels of one post: read them, dispute or appeal one, and (staff)
+ * decide a dispute.
+ *
+ * Budgets: 60 label reads per member an hour (25 of one author's posts) and
+ * 20 disputes a day. Past one, the server answers 429 with
+ * `X-RateLimit-Scope: action`: the SDK throws `RateLimitError` at once
+ * (`scope === 'action'`, `resetAt`, a member-facing `message`) and never
+ * retries it. Disputes and reviews answer 503 until the server's judgment
+ * store is applied; reads answer `status: 'unavailable'` instead.
+ */
+export class JudgmentsResource {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * One post's labels as the caller may see them. The post's author and staff
+     * get `view: 'full'` (every judgment with its answers, the safety verdict,
+     * Viral); any other member who can see the post gets `view: 'summary'` (the
+     * category and the compass band in words). `status: 'unavailable'` is
+     * returned, not thrown. A post the caller cannot see throws `NotFoundError`.
+     * Open-network posts need a key bound to an app (400 `app_required`).
+     *
+     * @example
+     * const { data } = await r.judgments.get({ kind: 'post', id: postId });
+     * if (data.status === 'ok' && data.view !== 'category' && data.politics) showBand(data.politics);
+     */
+    get(query) {
+        return this.client.get('/content-judgments', { kind: query.kind, id: query.id });
+    }
+    /**
+     * A signed-out visitor's view of one post's labels: the category only.
+     * Keyless: use an anonymous client (`new Recursiv({ anonymous: true })`).
+     */
+    getPublic(projectId, query) {
+        return this.client.get(`/protocols/public/${encodeURIComponent(projectId)}/content-judgments`, { kind: query.kind, id: query.id });
+    }
+    /**
+     * Disagree with a label. The post's author's dispute is an appeal and goes
+     * to the moderation queue; anyone else's feeds the evaluation and changes
+     * nothing on its own. One per member and judgment: a repeat returns the
+     * first with `existing: true`. Sent once, never retried automatically.
+     *
+     * @example
+     * await r.judgments.dispute(labels.politics.judgment_id, { question_key: 'placement', proposed: 'not_political' });
+     */
+    dispute(judgmentId, input) {
+        return this.client.post(path(judgmentId, 'disputes'), input, { retry: false });
+    }
+    /**
+     * Staff: uphold a disputed label, or vote to override it. A compass label
+     * changes when two reviewers propose the same answer (or one, beside an
+     * agreeing Jev re-judge): the first gets `status: 'awaiting_reviewer'`
+     * (HTTP 202). Every override is in the public moderation log.
+     *
+     * Sent once, never retried: an override that met its quorum but lost its
+     * response would otherwise be recorded again as a fresh vote. A safety
+     * override to `'none'` that would free other posts with exactly these words
+     * throws a 409 (`isJudgmentSharedWordsError`, `details.shared_posts`) until
+     * resent with `apply_to_shared: true`.
+     */
+    review(judgmentId, input) {
+        return this.client.post(path(judgmentId, 'reviews'), input, { retry: false });
+    }
+}

package/dist/resources/protocols.d.ts

@@ -1,5 +1,5 @@
 import type { HttpClient } from '../client.js';
-import type { CompassFilterMeta, DiscoveryLayout, PaginatedResponse, PaginationParams, SingleResponse } from '../types.js';
+import type { CompassFilterMeta, DiscoveryLayout, PaginatedResponse, PaginationParams, SingleResponse, StoryOutlets } 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"];
@@ -181,6 +181,134 @@ export interface ProtocolIngestionReplayResult {
     job_id: string;
     status: 'replayed';
 }
+/** A section of the ingestion health report that can fail to answer within its budget. */
+export type ProtocolIngestionHealthSection = 'activity' | 'circuits' | 'dead_letters' | 'jobs' | 'kill_switch' | 'lanes';
+/**
+ * Where a job is in its lane, read from its checkpoint: RSS reads one feed per page (feed_index); Hacker News and
+ * Event Registry walk term_index and page. Null when the checkpoint holds no such index.
+ */
+export interface ProtocolIngestionHealthPosition {
+    feed_index: number | null;
+    term_index: number | null;
+    page: number | null;
+}
+export interface ProtocolIngestionHealthRuntime {
+    mode: 'collector' | 'runtime';
+    enabled: boolean;
+    simulation: boolean;
+    global_kill_switch: boolean;
+    controls_valid: boolean;
+    project_allowed: boolean;
+    /** This app's operator kill switch; null when that read did not answer. */
+    kill_switch: boolean | null;
+}
+export interface ProtocolIngestionLaneJobs {
+    queued: number;
+    leased: number;
+    done: number;
+    dead: number;
+}
+/** The lane's open job (the worker keeps one open per lane). */
+export interface ProtocolIngestionLaneCurrentJob {
+    status: 'queued' | 'leased';
+    position: ProtocolIngestionHealthPosition;
+    pages_committed: number;
+    consecutive_failures: number;
+    last_error: string | null;
+    retry_at: string | null;
+    /** A leased job's lease end; null while queued. */
+    lease_until: string | null;
+    /** Leased, but the lease ran out and no worker reclaimed it (the worker died mid-page). */
+    lease_expired: boolean;
+    /** Eligible to run since then; null while a live lease holds it or it waits out a retry. */
+    waiting_since: string | null;
+    /** waiting_since once the wait passes the worker's starvation threshold (30 minutes); otherwise null. */
+    starved_since: string | null;
+}
+export interface ProtocolIngestionActivityReason {
+    status: 'retry' | 'dead' | 'invalid_job' | 'deferred' | 'abandoned';
+    reason: string | null;
+    count: number;
+}
+/** Attempts over the last window_hours; last success, last failure and failing_since look back lookback_days. */
+export interface ProtocolIngestionLaneActivity {
+    window_hours: number;
+    pages_committed: number;
+    /** Attempts that ended in a retry, a dead letter or an invalid job. */
+    failed: number;
+    deferred: number;
+    abandoned: number;
+    reasons: ProtocolIngestionActivityReason[];
+    lookback_days: number;
+    last_success_at: string | null;
+    last_failure_at: string | null;
+    /** The first failure after the last success; null when the newest finished attempt succeeded or none failed. */
+    failing_since: string | null;
+}
+export interface ProtocolIngestionDeadLetterGroup {
+    reason: string | null;
+    position: ProtocolIngestionHealthPosition;
+    count: number;
+    last_at: string | null;
+}
+/** Every dead job of the lane counted in total; the newest 20 (reason, position) groups listed. */
+export interface ProtocolIngestionLaneDeadLetters {
+    total: number;
+    last_dead_at: string | null;
+    groups: ProtocolIngestionDeadLetterGroup[];
+}
+/** One ingestion lane. A section that did not answer reads as null here and is named in the report's `unavailable`. */
+export interface ProtocolIngestionLaneHealth {
+    provider_id: string;
+    source_subscription_key: string;
+    active: boolean;
+    /** RSS only: the feeds this process reads, one page each, so a pass ends after feed_count pages. Null for other providers. */
+    feed_count: number | null;
+    jobs: ProtocolIngestionLaneJobs | null;
+    /** When a job of this lane last reached done (read every page of its pass). */
+    last_done_at: string | null;
+    /** Null when the lane has no open job or the jobs section is unavailable. */
+    current: ProtocolIngestionLaneCurrentJob | null;
+    activity: ProtocolIngestionLaneActivity | null;
+    dead_letters: ProtocolIngestionLaneDeadLetters | null;
+}
+/** A circuit row that is open, counting failures or killed: the provider's own, or (per-RSS-host circuit on) a fetch host's. */
+export interface ProtocolIngestionCircuitHealth {
+    provider_id: string;
+    kind: 'provider' | 'host';
+    /**
+     * A host circuit's fetch host: read from a readable key, or for a hashed key the configured feed host (with any
+     * explicit port) it belongs to. Null for the provider's own circuit and for a hashed key no configured feed names.
+     */
+    host: string | null;
+    /** The quota row key: `rss`, `rss--h-feeds_bbci_co_uk`, `rss--x-<hash>`. */
+    domain: string;
+    open: boolean;
+    open_until: string | null;
+    /**
+     * When the circuit last opened, or re-opened on a failed probe (open_until minus the open window). Null when it has
+     * not opened since it last closed.
+     */
+    opened_at: string | null;
+    /** Failures in a row since the circuit last closed (a host circuit's: feeds whose host never accepted the connection). */
+    failures: number;
+    killed: boolean;
+}
+/**
+ * Counts-only ingestion health for the key's app (audit row 8a): per lane, job counts, the open job's position,
+ * the last done, success and failure, 24-hour attempts by reason and dead letters by reason and position; plus the
+ * open or counting circuits. Never a checkpoint, payload, candidate or feed body.
+ */
+export interface ProtocolIngestionHealthReport {
+    generated_at: string;
+    runtime: ProtocolIngestionHealthRuntime;
+    /** Null when the lanes section is unavailable. */
+    lanes: ProtocolIngestionLaneHealth[] | null;
+    /** Open first. Null when the circuits section is unavailable. */
+    circuits: ProtocolIngestionCircuitHealth[] | null;
+    /** Sections that did not answer within their statement budget; their fields read as null. */
+    unavailable: ProtocolIngestionHealthSection[];
+}
 /** App/network scope comes only from the authenticated project-bound key. */
 export interface ListProtocolCandidatesParams {
     protocol?: string;
@@ -250,6 +378,14 @@ export type NativeNostrPrepareInput = {
     content: string;
     /** Your own post in this app (sdk.posts) that this note copies, so deleting it can offer this copy. */
     crossPostOf?: string;
+    /**
+     * A NIP-18 quote of one public note (0.7.71; accounts advertising `quote`). The server reads the note and adds its
+     * `q` and `p` tags and a `nostr:nevent` line after your text; review `quote` and the exact event before signing.
+     */
+    quote?: {
+        protocol: 'nostr';
+        nativeId: string;
+    };
 } | {
     action: 'reply';
     content: string;
@@ -662,13 +798,22 @@ export interface NativeReplyBatch {
 /** Public text and Minds-hosted images; accounts are selected explicitly in the shared editor. */
 export interface NativePostPrepareInput {
     clientMutationId: string;
+    /**
+     * The exact public text. Pass '' for a photo-only post (no words), which needs at least one `media`
+     * item: Bluesky gets an empty text with the images and Mastodon a status with only the photos, each
+     * photo's `alt` as its description. '' without media, or only spaces, is refused. Replies always need text.
+     */
     text: string;
     accountIds: string[];
     /** Minds-hosted images attached to every selected destination. Omit for a text-only post. */
     media?: NativeMediaInput[];
-    /** Native quote on Bluesky only. The server reads the source and permissions using each selected account. */
+    /**
+     * A native quote: a Bluesky record (`at://` URI), or a Mastodon status by its public URI (0.7.71) on a server that
+     * creates quote posts (Mastodon API version 7). The server reads the source and permissions using each selected account;
+     * a server without quote posts answers `quote_not_supported`, never a plain link. Nostr quotes use `prepareNativeNostr`.
+     */
     quote?: {
-        protocol: 'bluesky';
+        protocol: 'bluesky' | 'activitypub';
         nativeId: string;
     };
     /**
@@ -685,17 +830,24 @@ export interface NativePostBatch {
     deliveries: Array<Omit<NativeReplyBatch['deliveries'][number], 'kind' | 'parent' | 'recoverable' | 'replacedBy'> & {
         audience: 'public';
         maxCharacters: number;
-        quote?: {
-            protocol: 'bluesky';
-            nativeId: string;
-            cid: string;
-            authorId: string;
-            authorHandle: string;
-            sourceUrl: string;
-            text: string;
-        };
+        quote?: NativePostQuote;
     }>;
 }
+/** The reviewed quote of a delivery: Bluesky binds the record's CID, Mastodon the status's id on the member's server and its revision. */
+export type NativePostQuote = {
+    nativeId: string;
+    authorId: string;
+    authorHandle: string;
+    sourceUrl: string;
+    text: string;
+} & ({
+    protocol: 'bluesky';
+    cid: string;
+} | {
+    protocol: 'activitypub';
+    localId: string;
+    revision: string;
+});
 export interface NativeDelegatedPostHistoryItem {
     id: string;
     createdAt: string;
@@ -822,11 +974,22 @@ export interface NativeNostrPrepared {
         text: string;
         textTruncated?: boolean;
     };
+    /** The quoted note (a publish with `quote`), and the relay hint its `q` tag and `nostr:nevent` carry. */
+    quote?: {
+        protocol: 'nostr';
+        nativeId: string;
+        authorId: string;
+        authorHandle: string;
+        sourceUrl: string;
+        text: string;
+        textTruncated: boolean;
+        relay: string;
+    };
 }
 export interface NativeNostrAccount {
     enabled: boolean;
     identity: HostedProtocolIdentity | null;
-    capabilities: Array<'publish_original_text' | 'request_own_post_deletion' | 'reply_text_note' | 'publish_linked_text' | 'like' | 'unlike' | 'repost' | 'unrepost' | 'follow' | 'unfollow'>;
+    capabilities: Array<'publish_original_text' | 'request_own_post_deletion' | 'reply_text_note' | 'publish_linked_text' | 'quote' | 'like' | 'unlike' | 'repost' | 'unrepost' | 'follow' | 'unfollow'>;
     signing?: 'client';
 }
 export interface NativeNostrPostState {
@@ -1212,12 +1375,19 @@ export interface SocialRadarCluster {
      * or a party or politician. Hide politics (`compass: 'hide'`) leaves these out. Absent from a server before it was served.
      */
     political?: boolean;
+    /** Members per source kind, counted before the member cap: `outlet` counts articles, not outlets (use `outlets`). */
     sources: Partial<Record<SocialRadarSourceKind, number>>;
     corroboration: number;
+    /** Distinct outlets per lane; from 0.7.71's servers, `outlets`' two lanes. */
     laneMix: {
         mainstream: number;
         independent: number;
     };
+    /**
+     * How many outlets the story's coverage holds (StoryOutlets), from the members this read serves: the number its card,
+     * page, the News section and World Today all name. Absent from a server older than 0.7.71.
+     */
+    outlets?: StoryOutlets;
     velocity: {
         perHour: number;
         normalized: number;
@@ -1288,7 +1458,7 @@ export interface SocialRadarPosts {
 /** A story that has left the radar, as the radar's story archive keeps it (up to 30 days after it was last on the radar). */
 export interface SocialRadarStoryArchive {
     /** The story as the radar last published it. Articles keep their headline and link; a post is a member by reference only (no `title`). */
-    cluster: Pick<SocialRadarCluster, 'id' | 'label' | 'kind' | 'seed' | 'theme' | 'political' | 'sources' | 'laneMix'> & {
+    cluster: Pick<SocialRadarCluster, 'id' | 'label' | 'kind' | 'seed' | 'theme' | 'political' | 'sources' | 'laneMix' | 'outlets'> & {
         members: Array<Pick<SocialRadarMember, 'kind' | 'key' | 'url' | 'publishedAt' | 'outlet'> & {
             title?: string;
         }>;
@@ -1761,7 +1931,7 @@ export declare class ProtocolsResource {
     }): Promise<SingleResponse<NativeRepostReview>>;
     /** Reconcile the saved action without sending another native write. */
     nativeRepostStatus(id: string): Promise<SingleResponse<NativeRepostReview>>;
-    /** Prepare exact public text and reviewed images for selected connected Bluesky/ActivityPub accounts. */
+    /** Prepare exact public text, reviewed images and an optional native quote for selected connected Bluesky/ActivityPub accounts. */
     prepareNativePost(input: NativePostPrepareInput): Promise<SingleResponse<NativePostBatch>>;
     /** Explicitly approve selected deliveries; never auto-retry an uncertain write. */
     submitNativePost(id: string, input: {
@@ -2005,6 +2175,17 @@ export declare class ProtocolsResource {
      * project-admin authorization as listCandidates.
      */
     ingestionStatus(): Promise<SingleResponse<ProtocolIngestionStatus>>;
+    /**
+     * Read counts-only ingestion health for the key's app: per lane, whether it
+     * reaches done or dies part way (the open job's position, failures in a row,
+     * starvation, last success and failure, attempts by reason, dead letters by
+     * reason and position), plus open or counting circuits. Read-only. Needs a
+     * project-bound admin key and current project-admin authority, but not the
+     * content_intelligence_admin binding. Scope comes only from the key, so no
+     * query is sent (the API rejects one). A section that does not answer in its
+     * budget reads as null and is listed in `unavailable`.
+     */
+    ingestionHealth(): Promise<SingleResponse<ProtocolIngestionHealthReport>>;
     /** Turn the app's ingestion kill switch on: no reservation, screening or approval proceeds. */
     killIngestion(): Promise<SingleResponse<{
         kill_switch: true;

package/dist/resources/protocols.js

@@ -327,7 +327,7 @@ export class ProtocolsResource {
         hostedIdentityPath(id);
         return this.client.get(`/protocols/social/reposts/${encodeURIComponent(id)}`);
     }
-    /** Prepare exact public text and reviewed images for selected connected Bluesky/ActivityPub accounts. */
+    /** Prepare exact public text, reviewed images and an optional native quote for selected connected Bluesky/ActivityPub accounts. */
     prepareNativePost(input) {
         return this.client.post('/protocols/social/posts/prepare', { clientMutationId: input.clientMutationId,
             text: input.text, accountIds: input.accountIds,
@@ -479,7 +479,8 @@ export class ProtocolsResource {
     prepareNativeNostr(id, input) {
         hostedIdentityPath(id);
         const body = input.action === 'publish' ? { action: input.action, content: input.content,
-            ...(input.crossPostOf !== undefined ? { crossPostOf: input.crossPostOf } : {}) }
+            ...(input.crossPostOf !== undefined ? { crossPostOf: input.crossPostOf } : {}),
+            ...(input.quote ? { quote: { protocol: input.quote.protocol, nativeId: input.quote.nativeId } } : {}) }
             : input.action === 'reply' ? { action: input.action, content: input.content, parentId: input.parentId }
                 : input.action === 'linked_post' ? { action: input.action, content: input.content,
                     source: { protocol: input.source.protocol, nativeId: input.source.nativeId,
@@ -619,6 +620,19 @@ export class ProtocolsResource {
     ingestionStatus() {
         return this.client.get('/protocols/ingestion/status');
     }
+    /**
+     * Read counts-only ingestion health for the key's app: per lane, whether it
+     * reaches done or dies part way (the open job's position, failures in a row,
+     * starvation, last success and failure, attempts by reason, dead letters by
+     * reason and position), plus open or counting circuits. Read-only. Needs a
+     * project-bound admin key and current project-admin authority, but not the
+     * content_intelligence_admin binding. Scope comes only from the key, so no
+     * query is sent (the API rejects one). A section that does not answer in its
+     * budget reads as null and is listed in `unavailable`.
+     */
+    ingestionHealth() {
+        return this.client.get('/protocols/ingestion/health');
+    }
     /** Turn the app's ingestion kill switch on: no reservation, screening or approval proceeds. */
     killIngestion() {
         return this.client.post('/protocols/ingestion/kill', {});