@recursiv/sdk 0.7.121 → 0.7.122

package/README.md

@@ -104,6 +104,7 @@ for await (const chunk of r.agents.chatStream(agent.id, { message: 'Hello!' }))
 | `r.tags` | `create`, `list` |
 | `r.signals` | `batch` (up to 100 engagement signals, such as views, dwell and hides, for the member's own ranking; `keepalive` for a page-leave flush), `record` (one signal) (0.7.71); `clearViewingHistory` ("Clear my viewing history"); typed `SignalMetadata`, an id per event so a retry is stored once, and `duplicates`/`limited`/`rejected` in the answer (0.7.93) |
 | `r.privacy` | `capabilities` (the platform privacy facts the deployed API's build enforces, and its commit); pair with `@recursiv/sdk/privacy` (`PRIVACY_FACTS`, `isFactLive`, `liveFacts`) (unreleased) |
+| `r.sealed` | Sealed mode: `config`, `attestation`, `send`; for web Sealed's frame (unreleased): `frameToken` (a short-lived `sft_` credential for the frame), `me` (the member's own age view and Sealed adult setting), `report`; pair with `@recursiv/sdk/sealed` (the resource alone) and `@recursiv/sdk/sealed-frame` (below) |
 | `r.curator` | `today` (World Today; a world story can carry `story_key` and `discussion`, its count across networks), `storyPosts` / `memberStoryPosts` (one page of a story's posts, keyless or under the member's key), `storyPostPages` (walk every page), `forYou`, `run`, `refreshIfStale`, `seedDeck` |
 | `r.uploads` | `uploadMedia` — upload post/chat bytes end to end |
 | `r.judgments` | Jev's labels of a post (0.7.71): `get({ kind, id })` (the author and staff get every judgment and the safety verdict; other members the category and the compass band in words; `status: 'unavailable'` is returned, not thrown), keyless `getPublic(projectId, { kind, id })` (the category only), `dispute(judgmentId, { question_key, proposed, note? })` (the author's dispute is an appeal; a repeat returns `existing: true`), staff `review(judgmentId, { outcome, proposed?, note?, apply_to_shared? })` (sent once; 202 `awaiting_reviewer` until a compass label's second reviewer, or an agreeing Jev re-judge; `isJudgmentSharedWordsError` for the 409) |
@@ -478,6 +479,42 @@ if (match) {
 - `election`: only clear logistics (how, where or when to vote, registering, deadlines, polling places, mail or absentee ballots, voter ID, checking registration or a ballot). Never candidates, results, polls, fraud claims or votes on a post or poll. The US card points to vote.gov and CanIVote.org and the state election office; elsewhere the country's election authority, or a generic line.
 - English and Spanish. Every number and address has a cited source and an `as_of` date (`CRISIS_LINES`, `ELECTION_SITES`); a country with no checked entry gets the generic card, never a guessed number. `fixedCardFor(kind, options)` gives a card without a message.
 
+## Sealed frame (`@recursiv/sdk/sealed-frame`)
+
+Web Sealed runs in its own frame, served from its own origin (https://sealed.minds.com), so the page that embeds it can't read it. This browser-only subpath is protocol v1 for both sides: the host page uses `mountSealedFrame()` and `wipeSealedFrame()`, and the frame uses the same message types, builders and validators.
+
+```typescript
+import { mountSealedFrame, wipeSealedFrame } from '@recursiv/sdk/sealed-frame'
+
+const frame = mountSealedFrame({
+  container,                                  // size it with CSS; the frame never reports its height
+  frameOrigin: 'https://sealed.minds.com',
+  hostKind: 'minds',                          // or 'build'
+  scheme: 'dark',
+  layout: 'column',                           // or 'workspace'
+  account: member.id,                         // null when signed out: the frame wipes this browser's Sealed data
+  mintToken: () => r.sealed.frameToken(),     // called only when the frame asks, once per token life
+  onState: (state) => setSealedState(state),  // { state: 'ready' } or { state: 'unavailable', reason }
+  onNavigate: (to) => go(to),                 // 'plans' | 'settings_ai' | 'sign_in' | 'get_app'
+})
+
+frame.setTheme('light')
+await frame.signedOut()                       // 'wiped' | 'timeout' (1.5 s)
+frame.destroy()
+
+// Any sign-out path, with or without a frame on screen:
+await wipeSealedFrame({ frameOrigin: 'https://sealed.minds.com', account: member.id })
+```
+
+- The iframe is sandboxed (`allow-scripts allow-same-origin allow-popups allow-popups-to-escape-sandbox`), may only write to the clipboard, sends no referrer and is never `credentialless`.
+- On every load the host posts `sealed/hello` to the frame origin only with a MessagePort, and then reads that port only: a window message is never read, whatever its origin or source.
+- Every message is validated: an unknown type, a missing or extra field, a value outside its enum or pattern, or anything over 4 KB is dropped. Nothing the member types or reads ever crosses.
+- Tokens: one shared mint in flight, a token reused until 60 s before it expires, at least 30 s between two mints whatever the browser's clock says, and a failed mint held back 2 s doubling to 60 s (`onTokenError` gets the error; `isSealedWebOff(error)` means web Sealed is off). The cache belongs to one mount, so keep one mount while the page shows Sealed.
+- `signedOut()` always also runs the sign-out page, which records the wipe first; a frame that has had its hello but not said `ready` is reloaded, so its next hello is signed out.
+- The frame must not use `<form>` submission: the sandbox has no `allow-forms` (the frame CSP sets `form-action 'none'`), so an embedded form never fires `submit`. Handle Enter and the send button with key and click handlers.
+
+`@recursiv/sdk/sealed` exports `HttpClient`, `SealedResource` and the errors and nothing else, for a bundle that must hold only Sealed.
+
 ## Error handling
 
 ```typescript

package/dist/assistant-surfaces.d.ts

@@ -17,7 +17,7 @@
  * Every assistant surface an app may show, one switch each. All default off. Step numbers are the George plan's §8.
  * New ids are appended; an id is never renamed.
  */
-export declare const ASSISTANT_SURFACE_IDS: readonly ["post_button", "answer_sheet", "search_row", "top_bar", "inbox_row", "mentions", "chats", "e2ee_asks", "groups_catch_up", "translate", "compose", "profile_facts", "why_seeing", "daily_brief", "notes", "george_tab", "sealed_in_tab", "thread_summary", "selection", "topic_catch_up", "describe_image", "alt_text", "feed_steering", "share_answer"];
+export declare const ASSISTANT_SURFACE_IDS: readonly ["post_button", "answer_sheet", "search_row", "top_bar", "inbox_row", "mentions", "chats", "e2ee_asks", "groups_catch_up", "translate", "compose", "profile_facts", "why_seeing", "daily_brief", "notes", "george_tab", "sealed_in_tab", "thread_summary", "selection", "topic_catch_up", "describe_image", "alt_text", "feed_steering", "share_answer", "sealed_coming"];
 export type AssistantSurfaceId = (typeof ASSISTANT_SURFACE_IDS)[number];
 /** Every surface id with its switch, as the API sends it under `assistant.surfaces`. */
 export type AssistantSurfaces = Record<AssistantSurfaceId, boolean>;

package/dist/assistant-surfaces.js

@@ -70,6 +70,9 @@ export const ASSISTANT_SURFACE_IDS = [
     'feed_steering',
     // Sharing an answer as your own post. G27, not before 2026-11-04.
     'share_answer',
+    // The "Sealed · Coming" teaser (a pill and the sheet it opens) in the assistant tab. A Sealed launch item, not a
+    // George step: phone builds show it only while this is on, so it can be taken down without a new build.
+    'sealed_coming',
 ];
 const SURFACE_IDS = new Set(ASSISTANT_SURFACE_IDS);
 /** True for a surface id this SDK knows. */

package/dist/index.d.ts

@@ -236,8 +236,8 @@ export type { BookmarkCollection, BookmarkCollectionInput, BookmarkCollectionKin
 export { AccountsResource } from './resources/accounts.js';
 export { SIGNAL_BATCH_MAX, SignalsResource, newClientEventId } from './resources/signals.js';
 export type { ClearViewingHistoryResult, SignalBatchResult, SignalEventInput, SignalEventType, SignalExit, SignalMetadata, SignalNotRecordedReason, SignalRecordResult, SignalRejection, SignalSendOptions, SignalSurface, } from './resources/signals.js';
-export { SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SealedResource, SealedTransportError, } from './resources/sealed.js';
-export type { SealedAllowance, SealedAttestationInput, SealedConfig, SealedModel, SealedPlan, SealedPurpose, SealedQuotaDetails, SealedSendInput, SealedTarget, SealedTargetKind, SealedTransportErrorCode, } from './resources/sealed.js';
+export { SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SealedResource, SealedTransportError, SEALED_WEB_OFF, isSealedWebOff, } from './resources/sealed.js';
+export type { SealedAllowance, SealedAttestationInput, SealedConfig, SealedModel, SealedPlan, SealedPurpose, SealedQuotaDetails, SealedSendInput, SealedTarget, SealedTargetKind, SealedTransportErrorCode, SealedFrameToken, SealedMe, SealedMeBody, SealedOwnContent, SealedOwnPrivacy, SealedRefusalCode, SealedReportInput, SealedReportResult, } from './resources/sealed.js';
 export type { SiblingAccount, SiblingAccountsResponse, SwitchAccountResult, } from './resources/accounts.js';
 export type { LinkPreview, LinkPreviewResponse, LinkPreviewSource, } from './resources/link-preview.js';
 export type { AgentCapabilityConsentRequirement, AgentCapabilityDataSensitivity, AgentCapabilityDomain, AgentCapabilityExportBoundary, AgentCapabilityRetentionClass, AgentCapabilitySubdomain, AgentCapabilitySubject, AgentCapabilityTrustTier, AgentToolAudience, AgentToolScope, BrowserUseRunTaskInput, ProjectBrainSettings, ProjectToolBundleClassification, ProjectToolBundleKey, ProjectToolPermission, ProjectToolPermissionOverrides, UpdateProjectSettingsInput, } from './resources/project-brain.js';

package/dist/index.js

@@ -289,7 +289,7 @@ export { BOOKMARK_MERGE_MAX_ITEMS, BookmarkCollectionsResource, BookmarksResourc
 export { FEED_TOP_NETWORKS, FeedsResource } from './resources/feeds.js';
 export { AccountsResource } from './resources/accounts.js';
 export { SIGNAL_BATCH_MAX, SignalsResource, newClientEventId } from './resources/signals.js';
-export { SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SealedResource, SealedTransportError, } from './resources/sealed.js';
+export { SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SealedResource, SealedTransportError, SEALED_WEB_OFF, isSealedWebOff, } from './resources/sealed.js';
 export { OrganizationSettingsResource } from './resources/organization-settings.js';
 export { ProjectSettingsResource } from './resources/project-settings.js';
 export { OrganizationSecurityResource } from './resources/organization-security.js';

package/dist/resources/agents.d.ts

@@ -165,7 +165,7 @@ export interface SalesLead {
  * Validation happens server-side too; this list lets apps validate or
  * surface choices client-side without round-tripping the API.
  */
-export declare const SUPPORTED_MODELS: readonly ["anthropic/claude-fable-5", "anthropic/claude-fable-5.1", "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.8", "anthropic/claude-opus-5", "anthropic/claude-opus-5.5", "anthropic/claude-sonnet-4.6", "anthropic/claude-sonnet-5", "deepseek/deepseek-v3.2", "deepseek/deepseek-v4-pro", "google/gemini-3-flash-preview", "google/gemini-3.1-pro-preview", "google/gemini-3.5-flash", "google/gemini-3.8-flash", "minimax/minimax-m2.5", "minimax/minimax-m3", "moonshotai/kimi-k3", "openai/gpt-4o-mini", "openai/gpt-5.5", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-6-astra", "openai/gpt-6-sol", "x-ai/grok-4.3"];
+export declare const SUPPORTED_MODELS: readonly ["anthropic/claude-fable-5", "anthropic/claude-fable-5.1", "anthropic/claude-haiku-5.5", "anthropic/claude-opus-4.6", "anthropic/claude-opus-4.8", "anthropic/claude-opus-5", "anthropic/claude-opus-5.5", "anthropic/claude-sonnet-4.6", "anthropic/claude-sonnet-5", "anthropic/claude-sonnet-5.5", "deepseek/deepseek-v3.2", "deepseek/deepseek-v4-pro", "deepseek/deepseek-v4-pro-0813", "deepseek/deepseek-v4.1-flash", "google/gemini-3-flash-preview", "google/gemini-3.1-pro-preview", "google/gemini-3.5-flash", "google/gemini-3.8-flash", "meta-llama/llama-4-maverick", "minimax/minimax-m2.5", "minimax/minimax-m3", "moonshotai/kimi-k3", "openai/gpt-4o-mini", "openai/gpt-5.5", "openai/gpt-5.6-sol", "openai/gpt-5.6-terra", "openai/gpt-6-astra", "openai/gpt-6-luna", "openai/gpt-6-sol", "openai/gpt-6.1-sol", "qwen/qwen3.8-2.4t-a95b", "x-ai/grok-4.3", "x-ai/grok-4.7"];
 export type SupportedModel = (typeof SUPPORTED_MODELS)[number];
 export interface EnsurePersonalAgentOverrides {
     /** Override the agent's display name. Defaults to 'Agent'. */

package/dist/resources/agents.js

@@ -18,18 +18,23 @@ export const SUPPORTED_MODELS = [
     // <<< GENERATED: openrouter-sync — do not edit by hand (npm run models:sync)
     'anthropic/claude-fable-5',
     'anthropic/claude-fable-5.1',
+    'anthropic/claude-haiku-5.5',
     'anthropic/claude-opus-4.6',
     'anthropic/claude-opus-4.8',
     'anthropic/claude-opus-5',
     'anthropic/claude-opus-5.5',
     'anthropic/claude-sonnet-4.6',
     'anthropic/claude-sonnet-5',
+    'anthropic/claude-sonnet-5.5',
     'deepseek/deepseek-v3.2',
     'deepseek/deepseek-v4-pro',
+    'deepseek/deepseek-v4-pro-0813',
+    'deepseek/deepseek-v4.1-flash',
     'google/gemini-3-flash-preview',
     'google/gemini-3.1-pro-preview',
     'google/gemini-3.5-flash',
     'google/gemini-3.8-flash',
+    'meta-llama/llama-4-maverick',
     'minimax/minimax-m2.5',
     'minimax/minimax-m3',
     'moonshotai/kimi-k3',
@@ -38,8 +43,12 @@ export const SUPPORTED_MODELS = [
     'openai/gpt-5.6-sol',
     'openai/gpt-5.6-terra',
     'openai/gpt-6-astra',
+    'openai/gpt-6-luna',
     'openai/gpt-6-sol',
+    'openai/gpt-6.1-sol',
+    'qwen/qwen3.8-2.4t-a95b',
     'x-ai/grok-4.3',
+    'x-ai/grok-4.7',
     // >>> GENERATED
 ];
 export class AgentsResource {

package/dist/resources/sealed.d.ts

@@ -76,6 +76,12 @@ export interface SealedConfig {
      * a config you could not read, means off.
      */
     memory?: boolean;
+    /**
+     * Server switch (SEALED_GATEWAY_WEB): Sealed in a browser, through the Sealed frame. While it is off no frame token is
+     * minted or accepted (403 `sealed_web_off`), and `me()` and `report()` refuse every caller. Absent (an older gateway),
+     * or a config you could not read, means off: hide web Sealed.
+     */
+    web?: boolean;
     /** The attestation policy version the app's verifier must pin; an older pinned policy means the app needs updating. */
     verifier_policy_version: number;
     /** The member's allowance: its daily numbers are their plan's (`plan`). */
@@ -204,6 +210,81 @@ export declare class SealedTransportError extends Error {
     readonly code: SealedTransportErrorCode;
     constructor(code: SealedTransportErrorCode, message: string);
 }
+/**
+ * The `code` of a refusal the gateway wrote itself (RecursivError.code, and the X-Sealed-Gateway-Refusal header). The
+ * API's own answers (`invalid_api_key`, `rate_limited`, a 404 while Sealed is off for the app) carry other codes.
+ */
+export type SealedRefusalCode = 'sealed_unavailable' | 'sealed_member_key_required' | 'sealed_query_not_allowed' | 'sealed_enclave_required' | 'sealed_enclave_not_allowed' | 'sealed_body_required' | 'sealed_content_type' | 'sealed_request_too_large' | 'sealed_too_many_requests' | 'sealed_allowance_used' | 'sealed_upstream_unreachable' | 'sealed_upstream_unsealed' | 'sealed_method_not_allowed' | 'sealed_attestation_nonce_invalid' | 'sealed_attestation_target_not_allowed' | 'sealed_attestation_unavailable' | 'sealed_purpose_unknown' | 'sealed_search_mark_invalid' | 'sealed_search_off' | 'sealed_check_allowance_used' | 'sealed_search_allowance_used' | 'sealed_paused_today' | 'sealed_paused_budget'
+/** 403 while Sealed in a browser is off (SEALED_GATEWAY_WEB): no frame token is minted or accepted. */
+ | 'sealed_web_off'
+/** 403: a frame token on a route the frame does not use (the mint route among them). */
+ | 'sealed_frame_not_allowed'
+/** 403: a frame token sent from any origin but the frame origin it was minted for. */
+ | 'sealed_frame_origin'
+/** 400: a report body that is not `{ reason, details? }`. */
+ | 'sealed_report_invalid';
+/** The refusal code while Sealed in a browser is off (403, AuthorizationError). */
+export declare const SEALED_WEB_OFF = "sealed_web_off";
+/** Whether an error is the gateway's 403 `sealed_web_off`: Sealed in a browser is off, so hide web Sealed. */
+export declare function isSealedWebOff(error: unknown): boolean;
+/** What `frameToken()` returns: a short-lived credential for the Sealed frame, never an API key. */
+export interface SealedFrameToken {
+    /**
+     * The opaque frame token (`sft_…`). Hand it to the Sealed frame and nothing else: the frame keeps it in memory only.
+     * It is accepted only from `origin`, only on the frame's routes, only while the key that minted it is active, and
+     * never on the mint route, so a frame cannot renew itself.
+     */
+    token: string;
+    /** When it stops working, ISO 8601: the gateway grants 10 minutes by default, 15 at most. */
+    expiresAt: string;
+    /**
+     * How many seconds it lives, from the gateway's `expires_in`, so a host can time it without trusting the browser's
+     * clock. Absent while the gateway does not send `expires_in` (none does yet); mountSealedFrame() then uses `expiresAt`.
+     */
+    expiresIn?: number;
+    /** The frame origin it works from, e.g. `https://sealed.minds.com`. */
+    origin: string;
+}
+/** The member's own age view, as GET /settings/preferences gives it (`privacy`). */
+export interface SealedOwnPrivacy {
+    /** True only when the member answered the age question 18 or older. */
+    age_is_adult: boolean;
+    age_declared: boolean;
+    who_can_message_locked: boolean;
+}
+/** The member's own Sealed adult setting (D17). Through a frame token it is always false: D17 is off on the web. */
+export interface SealedOwnContent {
+    sealed_adult: boolean;
+}
+/** GET /sealed/me: the member's id, their own age view and their Sealed adult setting, and nothing else. */
+export interface SealedMeBody {
+    /** The member's user id: the frame checks it against the account its host named. */
+    user_id: string;
+    privacy: SealedOwnPrivacy;
+    content: SealedOwnContent;
+}
+/**
+ * What `me()` returns: the body, and the same fields again under `data`, the shape of `settings.getPreferences()`, so
+ * a reader written for that (minds lib/knownAge.ts, lib/sealedAdultSetting.ts) reads it unchanged.
+ */
+export interface SealedMe extends SealedMeBody {
+    data: SealedMeBody;
+}
+export interface SealedReportInput {
+    /** Why the member reports the answer: 1 to 100 characters. */
+    reason: string;
+    /** What the member chose to show Minds of the exchange: at most 2000 characters. */
+    details?: string;
+}
+/** What `report()` returns. */
+export interface SealedReportResult {
+    /** The report's id, or null when the reports service did not say. */
+    id: string | null;
+    /** True when it joined the member's open report of their own account. */
+    existing: boolean;
+    /** False when it joined an open report and its details did not fit there in full: the reason still reached staff. */
+    details_kept: boolean;
+}
 /** Set on a refusal the gateway wrote itself; a relayed router answer never carries it. */
 export declare const SEALED_REFUSAL_HEADER = "x-sealed-gateway-refusal";
 /**
@@ -218,6 +299,35 @@ export declare class SealedResource {
     constructor(client: HttpClient);
     /** The targets, models, verifier policy version and allowance the app needs before it seals anything. */
     config(): Promise<SealedConfig>;
+    /**
+     * A frame token for the Sealed frame (POST /sealed/frame-token), minted from this client's key, which must be the
+     * signed-in member's own key of a listed app. The host page calls it when its frame asks for a token and hands the
+     * token to the frame; `@recursiv/sdk/sealed-frame`'s mountSealedFrame() does that, minting at most once per token
+     * life. Asked once, never retried: past 30 a minute with `me()` the gateway answers 429.
+     *
+     * Throws AuthorizationError `sealed_web_off` while Sealed in a browser is off (`isSealedWebOff`),
+     * `sealed_member_key_required` for a key that may not mint one (an operator's, an IP- or origin-limited one) and
+     * `sealed_frame_not_allowed` when called with a frame token; RateLimitError `sealed_too_many_requests`; a
+     * RecursivError with status 503 `sealed_unavailable` while the gateway's frame settings are missing; NotFoundError
+     * while Sealed is off or not on for this app.
+     */
+    frameToken(): Promise<SealedFrameToken>;
+    /**
+     * The member's own id, age view and Sealed adult setting (GET /sealed/me): what Sealed reads before it opens a
+     * session, for the Sealed frame, which has no settings scope. Read with a frame token or the member's own key, only
+     * while Sealed in a browser is on (403 `sealed_web_off` otherwise). Through a frame token `content.sealed_adult` is
+     * always false. Returns the body and the same fields under `data`, so a `settings.getPreferences()` reader takes it
+     * as it is: `{ settings: { getPreferences: () => sealed.me() } }`. Asked once, never retried.
+     */
+    me(): Promise<SealedMe>;
+    /**
+     * Reports a Sealed answer (POST /sealed/reports), filed on the member's own account whatever the body names: the
+     * report carries only what the member chose to put in it. Only while Sealed in a browser is on (403
+     * `sealed_web_off`); every report spends the member's report budget (RateLimitError past it). Throws
+     * ValidationError `sealed_report_invalid` for a reason that is not 1 to 100 characters or details over 2000. Sent
+     * once, never retried, so a report is never filed twice by the SDK.
+     */
+    report(input: SealedReportInput): Promise<SealedReportResult>;
     /**
      * A target's attestation document, fetched through the gateway so Tinfoil sees the gateway's address rather than the
      * phone's. Returns the document's bytes exactly as the target served them, for the verifier (packages/e2ee attest),

package/dist/resources/sealed.js

@@ -7,6 +7,12 @@ export class SealedTransportError extends Error {
         this.code = code;
     }
 }
+/** The refusal code while Sealed in a browser is off (403, AuthorizationError). */
+export const SEALED_WEB_OFF = 'sealed_web_off';
+/** Whether an error is the gateway's 403 `sealed_web_off`: Sealed in a browser is off, so hide web Sealed. */
+export function isSealedWebOff(error) {
+    return error instanceof RecursivError && error.status === 403 && error.code === SEALED_WEB_OFF;
+}
 /** Set on a refusal the gateway wrote itself; a relayed router answer never carries it. */
 export const SEALED_REFUSAL_HEADER = 'x-sealed-gateway-refusal';
 /**
@@ -37,6 +43,46 @@ export class SealedResource {
     async config() {
         return this.client.get('/sealed/config');
     }
+    /**
+     * A frame token for the Sealed frame (POST /sealed/frame-token), minted from this client's key, which must be the
+     * signed-in member's own key of a listed app. The host page calls it when its frame asks for a token and hands the
+     * token to the frame; `@recursiv/sdk/sealed-frame`'s mountSealedFrame() does that, minting at most once per token
+     * life. Asked once, never retried: past 30 a minute with `me()` the gateway answers 429.
+     *
+     * Throws AuthorizationError `sealed_web_off` while Sealed in a browser is off (`isSealedWebOff`),
+     * `sealed_member_key_required` for a key that may not mint one (an operator's, an IP- or origin-limited one) and
+     * `sealed_frame_not_allowed` when called with a frame token; RateLimitError `sealed_too_many_requests`; a
+     * RecursivError with status 503 `sealed_unavailable` while the gateway's frame settings are missing; NotFoundError
+     * while Sealed is off or not on for this app.
+     */
+    async frameToken() {
+        const body = await this.client.post('/sealed/frame-token', {}, { retry: false });
+        const expiresIn = typeof body.expires_in === 'number' && Number.isFinite(body.expires_in) ? body.expires_in : undefined;
+        return { token: body.token, expiresAt: body.expires_at, ...(expiresIn !== undefined ? { expiresIn } : {}), origin: body.origin };
+    }
+    /**
+     * The member's own id, age view and Sealed adult setting (GET /sealed/me): what Sealed reads before it opens a
+     * session, for the Sealed frame, which has no settings scope. Read with a frame token or the member's own key, only
+     * while Sealed in a browser is on (403 `sealed_web_off` otherwise). Through a frame token `content.sealed_adult` is
+     * always false. Returns the body and the same fields under `data`, so a `settings.getPreferences()` reader takes it
+     * as it is: `{ settings: { getPreferences: () => sealed.me() } }`. Asked once, never retried.
+     */
+    async me() {
+        const body = await this.client.get('/sealed/me', undefined, { retry: false });
+        const own = { user_id: body.user_id, privacy: body.privacy, content: body.content };
+        return { ...own, data: { ...own } };
+    }
+    /**
+     * Reports a Sealed answer (POST /sealed/reports), filed on the member's own account whatever the body names: the
+     * report carries only what the member chose to put in it. Only while Sealed in a browser is on (403
+     * `sealed_web_off`); every report spends the member's report budget (RateLimitError past it). Throws
+     * ValidationError `sealed_report_invalid` for a reason that is not 1 to 100 characters or details over 2000. Sent
+     * once, never retried, so a report is never filed twice by the SDK.
+     */
+    async report(input) {
+        const body = { reason: input.reason, ...(input.details !== undefined ? { details: input.details } : {}) };
+        return this.client.post('/sealed/reports', body, { retry: false });
+    }
     /**
      * A target's attestation document, fetched through the gateway so Tinfoil sees the gateway's address rather than the
      * phone's. Returns the document's bytes exactly as the target served them, for the verifier (packages/e2ee attest),

package/dist/sealed/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `@recursiv/sdk/sealed`: the Sealed resource alone, for a bundle that must hold nothing else, such as the Sealed frame
+ * (https://sealed.minds.com), whose every file is listed and reviewed by hand. It carries HttpClient, SealedResource and
+ * the errors, and no other resource: the main entry builds every resource the API has.
+ *
+ * ```ts
+ * import { HttpClient, SealedResource } from '@recursiv/sdk/sealed'
+ * const sealed = new SealedResource(new HttpClient({ apiKey: frameToken, baseUrl: 'https://api.minds.com/api/v1' }))
+ * ```
+ *
+ * HttpClient fixes its key when it is made, so a frame that renews its token builds a new SealedResource each time.
+ * A bundle test (src/__tests__/sealed-subpath.bundle.test.ts) fails if this entry reaches any other resource.
+ */
+export { HttpClient } from '../client.js';
+export { isSealedWebOff, SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SEALED_WEB_OFF, SealedResource, SealedTransportError, } from '../resources/sealed.js';
+export type { SealedAllowance, SealedAttestationInput, SealedConfig, SealedFrameToken, SealedMe, SealedMeBody, SealedModel, SealedOwnContent, SealedOwnPrivacy, SealedPlan, SealedPurpose, SealedQuotaDetails, SealedRefusalCode, SealedReportInput, SealedReportResult, SealedSendInput, SealedTarget, SealedTargetKind, SealedTransportErrorCode, } from '../resources/sealed.js';
+export { AuthenticationError, AuthorizationError, ConflictError, InsufficientCreditsError, NotFoundError, RateLimitError, RecursivError, ValidationError, } from '../errors.js';
+export type { RateLimitDetails } from '../errors.js';
+export type { RecursivConfig } from '../types.js';

package/dist/sealed/index.js

@@ -0,0 +1,16 @@
+/**
+ * `@recursiv/sdk/sealed`: the Sealed resource alone, for a bundle that must hold nothing else, such as the Sealed frame
+ * (https://sealed.minds.com), whose every file is listed and reviewed by hand. It carries HttpClient, SealedResource and
+ * the errors, and no other resource: the main entry builds every resource the API has.
+ *
+ * ```ts
+ * import { HttpClient, SealedResource } from '@recursiv/sdk/sealed'
+ * const sealed = new SealedResource(new HttpClient({ apiKey: frameToken, baseUrl: 'https://api.minds.com/api/v1' }))
+ * ```
+ *
+ * HttpClient fixes its key when it is made, so a frame that renews its token builds a new SealedResource each time.
+ * A bundle test (src/__tests__/sealed-subpath.bundle.test.ts) fails if this entry reaches any other resource.
+ */
+export { HttpClient } from '../client.js';
+export { isSealedWebOff, SEALED_ALLOWANCE_REMAINING_HEADER, SEALED_REFUSAL_HEADER, SEALED_WEB_OFF, SealedResource, SealedTransportError, } from '../resources/sealed.js';
+export { AuthenticationError, AuthorizationError, ConflictError, InsufficientCreditsError, NotFoundError, RateLimitError, RecursivError, ValidationError, } from '../errors.js';

package/dist/sealed-frame/host.d.ts

@@ -0,0 +1,98 @@
+import { type SealedFrameHostKind, type SealedFrameLayout, type SealedFrameNavigateTarget, type SealedFrameScheme, type SealedFrameUnavailableReason } from './protocol.js';
+/**
+ * What the host shows for the frame: the frame's own `state`, or one the host decides itself:
+ * - `update` when the frame speaks another protocol version ("Reload the page");
+ * - `no_answer` when the frame did not answer its hello in time (it failed to load, or is not the Sealed frame).
+ */
+export type SealedFrameHostState = {
+    state: 'ready';
+} | {
+    state: 'unavailable';
+    reason: SealedFrameUnavailableReason | 'no_answer';
+};
+/** What `mintToken` resolves to: `sdk.sealed.frameToken()`'s answer fits. */
+export interface SealedFrameMintedToken {
+    token: string;
+    /** When it expires: an ISO 8601 time, ms since the epoch, or a Date. Read against this browser's clock. */
+    expiresAt: string | number | Date;
+    /**
+     * How many seconds it lives, as the API counted when it minted it. When given, the host times the token from when it
+     * asked for it instead of from `expiresAt`, so a browser clock that runs fast or slow does not matter.
+     */
+    expiresIn?: number;
+    /** The frame origin the token works from. When given, it must be this frame's origin, or the token is not used. */
+    origin?: string;
+}
+export interface MountSealedFrameOptions {
+    /** The element the frame fills. Size it with CSS: the frame never says how tall its content is. */
+    container: HTMLElement;
+    /** The frame origin, e.g. `https://sealed.minds.com` (staging `https://sealed-staging.minds.com`). */
+    frameOrigin: string;
+    hostKind: SealedFrameHostKind;
+    scheme: SealedFrameScheme;
+    layout: SealedFrameLayout;
+    /** The signed-in member's user id, or null when no one is signed in (the frame then wipes this browser's Sealed data). */
+    account: string | null;
+    /**
+     * Mints a frame token for the signed-in member, e.g. `() => sdk.sealed.frameToken()`. Called only when the frame asks
+     * and the last token is within 60 s of expiring (or was refused), never twice at once (concurrent asks share one
+     * call), and at least 30 s after the last mint that worked, whatever the browser's clock says. A failure is passed to
+     * `onTokenError`, and asks are then held back, 2 s doubling to 60 s, before the next call.
+     */
+    mintToken: () => Promise<SealedFrameMintedToken>;
+    onState?: (state: SealedFrameHostState) => void;
+    onNavigate?: (to: SealedFrameNavigateTarget) => void;
+    /** A mint that failed or gave something unusable: `isSealedWebOff(error)` from `@recursiv/sdk` means hide web Sealed. */
+    onTokenError?: (error: unknown) => void;
+    /** The iframe's accessible name. `Sealed chat` by default. */
+    title?: string;
+    /**
+     * How long the frame has to answer, from the mount and again from each load, before the host reports `no_answer`.
+     * 15 s by default.
+     */
+    readyTimeoutMs?: number;
+}
+export interface SealedFrameHandle {
+    /** The frame's iframe, already in `container`. */
+    readonly iframe: HTMLIFrameElement;
+    setTheme(scheme: SealedFrameScheme): void;
+    setLayout(layout: SealedFrameLayout): void;
+    /** The member switched accounts: the frame drops its session and token, and the host its cached token. */
+    setAccount(account: string): void;
+    /**
+     * The member signed out: the frame wipes the account's Sealed data. Always also runs the sign-out page
+     * (wipeSealedFrame), which records the wipe first so one cut short (the frame mid-reload, or the page reloading now)
+     * finishes on the frame's next load. Resolves `wiped` when either says so, or `timeout` after `timeoutMs` (1500 ms
+     * by default). A frame that has had its hello but not said `ready` is reloaded, so its next hello is signed out (which
+     * wipes every account's Sealed data) and it never runs on as the account its first hello named. The host forgets the
+     * account and its token at once either way.
+     */
+    signedOut(options?: {
+        timeoutMs?: number;
+    }): Promise<'wiped' | 'timeout'>;
+    newChat(): void;
+    /** Removes the frame and closes its port. Every method is a no-op afterwards; a pending signedOut() gets `timeout`. */
+    destroy(): void;
+}
+/**
+ * A cached token is handed out until this long before it expires (later only to a frame load that does not hold it,
+ * while the next mint is held back); the frame asks again then.
+ */
+export declare const SEALED_FRAME_TOKEN_REFRESH_MS = 60000;
+/**
+ * Embeds the Sealed frame in `container` and runs the host's side of protocol v1 (protocol.ts). The iframe is
+ * sandboxed (SEALED_FRAME_SANDBOX), may only write to the clipboard, sends no referrer, and is never `credentialless`
+ * (that would give the frame a throwaway storage partition and lose the member's Sealed chats).
+ *
+ * On every load of the iframe the host posts `sealed/hello` to the frame origin only, with a new MessagePort, and from
+ * then on reads that port only: a window message is never read, whatever its origin or source, and a port from an
+ * earlier load is closed. Nothing counts until the frame answers `ready`.
+ *
+ * `need-token` is answered through `mintToken`, minting at most once per token life and never twice in 30 s (see
+ * MountSealedFrameOptions), so reloading the frame, a frame that asks too often or a wrong browser clock never storms
+ * the API. The token cache belongs to one mount: keep one mount for as long as the page shows Sealed, since each new
+ * mount mints afresh on its frame's first ask.
+ *
+ * Browser only: call it in an effect, and `destroy()` on unmount.
+ */
+export declare function mountSealedFrame(options: MountSealedFrameOptions): SealedFrameHandle;