@anuma/sdk 10.0.4 → 10.1.0

package/dist/react/index.d.mts

@@ -1,4 +1,4 @@
-import { Model, Database, Collection } from '@nozbe/watermelondb';
+import { Database, Model, Collection } from '@nozbe/watermelondb';
 import Model$1, { Associations } from '@nozbe/watermelondb/Model';
 import * as _nozbe_watermelondb_Schema_migrations from '@nozbe/watermelondb/Schema/migrations';
 import * as _nozbe_watermelondb_Schema from '@nozbe/watermelondb/Schema';
@@ -3187,1101 +3187,1059 @@ interface WebSearchPreProcessorOptions {
  */
 declare function createWebSearchPreProcessor(options?: WebSearchPreProcessorOptions): PromptPreProcessor;
 
-type ChatRecordKind = "conversation" | "message" | "summary" | "project" | "memory_links";
-type ChatJson = null | boolean | number | string | ChatJson[] | {
-    [key: string]: ChatJson;
-};
-/** Whole-record JSON data is encrypted on the device, including all text, vectors and tool events. */
-interface ChatRecord {
-    kind: ChatRecordKind;
-    id: string;
-    conversationId: string;
-    sortKey: number;
-    createdAt: number;
-    updatedAt: number;
-    isDeleted: boolean;
-    data: {
-        [key: string]: ChatJson;
-    };
-}
-interface ChatSnapshot {
-    record: ChatRecord;
-    version: number;
-    serverUpdatedAt: string;
-}
-interface ChatWrite {
-    record: ChatRecord;
-    expectedVersion: number;
-    /** Sent and stored unencrypted so vault can run vector search. */
-    embeddings?: number[][];
-    embeddingModel?: string;
-}
-interface ChatRef {
-    kind: ChatRecordKind;
-    id: string;
-}
-type ChatAccountState = "none" | "migrating" | "active";
-interface ChatAccount {
-    keyId: string;
-    state: ChatAccountState;
-    recordCount: number;
-    storageBytes: number;
-    vectorCount: number;
-}
-interface ChatImport {
-    record: ChatRecord;
-    /** Sent and stored unencrypted so vault can run vector search. */
-    embeddings?: number[][];
-    embeddingModel?: string;
-}
-interface ChatRevision {
-    kind: ChatRecordKind;
-    id: string;
-    updatedAt: number;
-    isDeleted: boolean;
-}
-interface ChatChanges {
-    items: ChatSnapshot[];
-    nextCursor?: string;
-    changesCursor: string;
-}
-interface ChatSearchOptions {
-    limit?: number;
-    kinds?: ("message" | "summary")[];
-    conversationId?: string;
-    signal?: AbortSignal;
-}
-interface ChatSearchHit extends ChatSnapshot {
-    chunk: number;
-    score: number;
-}
-interface ChatAttachment {
-    id: string;
-    sizeBytes: number;
-    state: "pending" | "committed";
-    ownerKind?: "message" | "summary";
-    ownerId?: string;
-    createdAt: string;
-    committedAt?: string;
-}
-interface ChatPresignedUrl {
-    url: string;
-    method: string;
-    headers: Record<string, string>;
-    expiresAt: string;
-}
-interface ChatAttachments {
-    create(sizeBytes: number, signal?: AbortSignal): Promise<{
-        attachment: ChatAttachment;
-        upload: ChatPresignedUrl;
-    }>;
-    commit(attachmentId: string, owner: {
-        kind: "message" | "summary";
-        id: string;
-    }, signal?: AbortSignal): Promise<ChatAttachment>;
-    get(attachmentId: string, signal?: AbortSignal): Promise<{
-        attachment: ChatAttachment;
-        download?: ChatPresignedUrl;
-    } | null>;
-    delete(attachmentId: string, signal?: AbortSignal): Promise<void>;
-}
-interface ChatListOptions {
-    kind: ChatRecordKind;
-    conversationId?: string;
-    includeDeleted?: boolean;
-    cursor?: string;
-    limit?: number;
-    signal?: AbortSignal;
-}
-interface ChatPage {
-    items: ChatSnapshot[];
-    nextCursor?: string;
-    total?: number;
-}
-/** Explicit versions protect edits; ambiguous writes are never replayed automatically. */
-interface ChatStore {
-    get(kind: ChatRecordKind, id: string, signal?: AbortSignal): Promise<ChatSnapshot | null>;
-    list(options: ChatListOptions): Promise<ChatPage>;
-    putMany(writes: readonly ChatWrite[], signal?: AbortSignal): Promise<ChatSnapshot[]>;
-    getMany(refs: readonly ChatRef[], signal?: AbortSignal): Promise<ChatSnapshot[]>;
-    account(signal?: AbortSignal): Promise<ChatAccount>;
-    importRecords(records: readonly ChatImport[], signal?: AbortSignal): Promise<number>;
-    verify(revisions: readonly ChatRevision[], signal?: AbortSignal): Promise<ChatRef[]>;
-    activate(signal?: AbortSignal): Promise<boolean>;
-    changes(cursor?: string, options?: {
-        limit?: number;
-        signal?: AbortSignal;
-    }): Promise<ChatChanges>;
-    search(embedding: readonly number[], options?: ChatSearchOptions): Promise<ChatSearchHit[]>;
-    deleteAll(signal?: AbortSignal): Promise<number>;
-    attachments: ChatAttachments;
-}
-interface RemoteChatStoreOptions {
-    baseUrl: string;
-    getToken: () => Promise<string | null>;
-    keyId: string;
-    encrypt: (plaintext: string) => Promise<string>;
-    decrypt: (ciphertext: string) => Promise<string>;
-    fetch?: typeof globalThis.fetch;
-    timeoutMs?: number;
-    signal?: AbortSignal;
-}
-declare class ChatStoreError extends Error {
-    readonly status: number;
-    readonly code?: string | undefined;
-    readonly retryAfterMs?: number | undefined;
-    constructor(message: string, status: number, code?: string | undefined, retryAfterMs?: number | undefined);
-}
-
-/** Connect to owner-scoped server storage using the account's canonical device-held cipher. */
-declare function createRemoteChatStore(options: RemoteChatStoreOptions): Promise<ChatStore>;
-
-declare class AppFile extends Model {
-    static table: string;
-    static associations: Associations;
-    conversationId: string;
-    path: string;
-    content: string;
-    createdAt: Date;
-    updatedAt: Date;
-}
-
 /**
- * Types for the app files storage module.
+ * Encryption key version type.
+ * - "v2": Legacy SHA-256 derived key (for reading enc:v2: data)
+ * - "v3": HKDF derived key with domain separation (for new encryption)
  *
- * App files are the HTML/CSS/JS source files for LLM-generated apps,
- * stored per conversation. Each file is identified by a conversationId + path pair.
+ * Raw signature bytes (Privy Solana `signMessage` returns a `Uint8Array`) are
+ * not a stored version. Derive them with {@link deriveKeyFromSignatureBytes}.
+ * {@link requestEncryptionKey} still derives v2 and v3 from a hex signature only.
  */
-/** Plain object representation of an app file record. */
-interface StoredAppFile {
-    /** WatermelonDB internal ID */
-    uniqueId: string;
-    /** The conversation this file belongs to */
-    conversationId: string;
-    /** Normalized file path, no leading slash (e.g. "index.html", "src/App.tsx") */
-    path: string;
-    /** File content (UTF-8 text) */
-    content: string;
-    createdAt: Date;
-    updatedAt: Date;
+type EncryptionKeyVersion = "v2" | "v3";
+/**
+ * Thrown by {@link getEncryptionKey} when the requested version is absent.
+ * Distinct from AES-GCM auth-tag failures so decrypt callers can tell
+ * "need to derive/hydrate this version" from "wrong key for intact ciphertext".
+ */
+declare class EncryptionKeyMissingError extends Error {
+    readonly address: string;
+    readonly version: EncryptionKeyVersion;
+    constructor(address: string, version: EncryptionKeyVersion);
 }
-
-/** Context required by app file operations. */
-interface AppFileOperationsContext {
-    database: Database;
-    appFilesCollection: Collection<AppFile>;
+/**
+ * Options for {@link requestEncryptionKey}.
+ */
+interface RequestEncryptionKeyOptions {
+    /**
+     * When true, re-derive and replace any existing in-memory keys for this
+     * address. Default false preserves the historical "if present, return"
+     * short-circuit. Prefer {@link refreshEncryptionKeyIfMatches} when the
+     * caller has ciphertext that must keep working — force-replace can pin a
+     * newly derived wrong key over a still-valid one.
+     */
+    force?: boolean;
 }
-/** Convert a WatermelonDB AppFile model to a plain StoredAppFile object. */
-declare function appFileToStored(file: AppFile): StoredAppFile;
 /**
- * Create or overwrite a file. If a file with the same conversationId + path
- * already exists, it is updated in place.
+ * Register a callback that fires when an encryption key becomes available for an address.
+ * If the key is already available, the callback fires immediately.
+ * @returns Unsubscribe function
  */
-declare function putAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string, content: string): Promise<StoredAppFile>;
-/** Read a single file by conversationId and path. Returns null if not found. */
-declare function getAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string): Promise<StoredAppFile | null>;
-/** List all files for a conversation. */
-declare function getAppFilesOp(ctx: AppFileOperationsContext, conversationId: string): Promise<StoredAppFile[]>;
-/** Get all files for a conversation as a path → content map (for sending to the runner). */
-declare function getAppFileMapOp(ctx: AppFileOperationsContext, conversationId: string): Promise<Record<string, string>>;
-/** Delete a single file by conversationId and path. */
-declare function deleteAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string): Promise<boolean>;
-/** Delete all files for a conversation. */
-declare function deleteAllAppFilesOp(ctx: AppFileOperationsContext, conversationId: string): Promise<void>;
-
+declare function onKeyAvailable(address: string, callback: () => void): () => void;
 /**
- * Drop every cached plaintext title and pending decrypt promise.
- *
- * Wired into `clearAllEncryptionState()` via the listener registry in
- * `useEncryption.ts`. Also exported so consumers can clear the cache
- * proactively (e.g. on wallet switch within a session before the
- * full encryption-state teardown lands).
+ * Clears the encryption key for a wallet address from memory
+ * @param address - The wallet address
  */
-declare function clearLazyTitleCache(): void;
+declare function clearEncryptionKey(address: string): void;
 /**
- * Decrypt a single conversation title on demand.
+ * Clears all encryption-related state from memory and any derived persistence.
  *
- * Designed for the lazy display path: pair with `listConversationsLazy`
- * and call this once a row is actually visible.
+ * This is the canonical session-teardown entry point. It wipes every module-level
+ * map that retains key material or listeners tied to a session: the raw
+ * encryption keys, cached imported CryptoKey objects, availability callbacks,
+ * pending sign-in flights, and derived ECDH key pairs. It also removes any
+ * persisted ECDH key pairs from localStorage so they can't be decrypted by a
+ * subsequent user on a shared browser.
  *
- * Behavior:
- *   - Plaintext input (no `enc:` prefix) is returned unchanged. This
- *     covers conversations created before encryption was enabled and
- *     keeps the helper safe to call unconditionally from rendering
- *     code that may receive a mix of encrypted and plaintext titles.
- *   - Encrypted input is decrypted via `decryptField`, which uses the
- *     same per-version cached `CryptoKey` as the eager path — no new
- *     key derivations are triggered.
- *   - Concurrent calls for the same `(address, encryptedTitle)` share
- *     a single decrypt promise.
- *   - The result is memoized in a 256-entry LRU.
+ * Call this on logout / session-end to prevent cross-user key leakage on shared
+ * browsers. If you manage auth outside the SDK, wire this into your logout flow.
  *
- * Throws if the encryption key for `address` isn't loaded. (The
- * underlying `decryptField` would otherwise silently return the
- * ciphertext, which would surface to the UI as a literal `enc:v3:...`
- * title — strictly worse than a thrown error the caller can catch.)
+ * @example
+ * ```tsx
+ * import { clearAllEncryptionState } from "@anuma/sdk/react";
  *
- * @param encryptedTitle - The stored title. May be ciphertext or plaintext.
- * @param address - Wallet address that owns the encryption key.
- * @returns The decrypted plaintext title.
+ * async function handleLogout() {
+ *   clearAllEncryptionState();
+ *   await privy.logout();
+ * }
+ * ```
  */
-declare function decryptConversationTitle(encryptedTitle: string, address: string): Promise<string>;
-
-declare class VaultMemory extends Model {
-    static table: string;
-    content: string;
-    scope: string;
-    /** Profile kind, or null for a free-form memory. */
-    kind: string | null;
-    /** Canonical JSON value of a kinded memory, encrypted at rest. */
-    kindValue: string | null;
-    /** private | matching | profile. */
-    level: string | null;
-    folderId: string | null;
-    userId: string | null;
-    embedding: string | null;
-    /** Model that produced `embedding`. Null on legacy rows (grandfathered). */
-    embeddingModel: string | null;
-    sourceChunkIds: string | null;
-    proofCount: number | null;
-    source: string | null;
-    /** W6 temporal lane — Unix ms timestamp of when the event occurred. */
-    eventTimeStart: number | null;
-    /** W6 temporal lane — Unix ms timestamp of event end (range/ongoing). */
-    eventTimeEnd: number | null;
-    /** W6 temporal lane — `point | range | ongoing | null`. */
-    eventTimeKind: string | null;
-    /** When true, the user has manually set this memory's topics; auto-extraction
-     *  leaves its entity links alone. Null on legacy rows (treated as false). */
-    topicsUserManaged: boolean | null;
-    /** The durable, synced record of this memory's topics — JSON `StoredTopic[]`.
-     *  `entity` / `memory_entity` are a device-local index over it. Null = pre-v42
-     *  (backfilled from the row's current links by the sweep). */
-    topics: string | null;
-    /** Unix ms of the last `topics` write. Separate from `updated_at`, which every
-     *  topic writer pins on purpose (recall recency) — see the schema note. */
-    topicsUpdatedAt: number | null;
-    /** The photo(s) a SERVER-EXTRACTED memory came from — JSON
-     *  `[{feed_item_id, object_key}]`, exactly the shape
-     *  GET /api/memories/published returns. Null on anything not from a photo. */
-    media: string | null;
-    /** Unix ms of the last LLM topic-extraction pass. Null = never extracted
-     *  standalone (linked legacy rows are grandfathered as extracted).
-     *  DEPRECATED (v42) — subsumed by `topics_updated_at`; see the schema note. */
-    topicsExtractedAt: number | null;
-    /** A2 supersession: newer memory id that replaced this one, or null if live. */
-    supersededBy: string | null;
-    supersededAt: number | null;
-    /** Extraction-logic version this memory was last stamped under. Null (pre-v38)
-     *  reads as 0, so a TOPICS_EXTRACTION_VERSION bump re-extracts stale rows.
-     *  DEPRECATED (v42) — subsumed by `topics_updated_at`; see the schema note. */
-    topicsExtractedVersion: number | null;
-    /** C3 re-observation watermark: Unix ms of the last retain() merge, or null. */
-    lastObservedAt: number | null;
-    /** Typed memory (PR1) — the extractor's FactType. Null on legacy/manual rows. */
-    factType: string | null;
-    /** Decay archive state (PR2) — Unix ms when archived, null when active. */
-    archivedAt: number | null;
-    /** Tier-0 security (PR3) — "quarantined" | "trusted" | null. */
-    trustTier: string | null;
-    /** People Nearby visibility: 'private' | 'public'. Null on legacy rows, and
-     *  any unrecognised value, read as 'private' — never published without opt-in. */
-    visibility: string | null;
-    /** Owner opted this memory into their own digital twin (twin-scoped only). */
-    twinOptIn: boolean | null;
-    /** Unix ms when visibility last became non-private; null while private. */
-    publishedAt: number | null;
-    /** Reserved coarse-geohash slot for landmark/Trail memories. */
-    geohash: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-    isDeleted: boolean;
-}
-
+declare function clearAllEncryptionState(): void;
 /**
- * A canonical entity (person, place, thing) extracted from the user's
- * conversations. Many-to-many with vault memories via {@link MemoryEntity}.
+ * Clears all encryption keys from memory.
  *
- * Created on the write path by the auto-extraction worker (W2) when a
- * candidate fact arrives with non-empty `entities[]`. Used at retrieval
- * time as a 3rd RRF lane (W5 graph traversal): query entity overlap
- * with stored memories surfaces topically-related facts that pure
- * semantic search misses.
- */
-declare class Entity extends Model {
-    static table: string;
-    /** Lowercased, trimmed name used for dedup and lookup. */
-    canonicalName: string;
-    /** Optional category — "person" | "place" | "thing" | "concept" | etc. */
-    kind: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-}
-/**
- * Join row: a memory references an entity (and vice versa). Multiple
- * rows per memory (one per entity) and per entity (one per memory).
- */
-declare class MemoryEntity extends Model {
-    static table: string;
-    memoryId: string;
-    entityId: string;
-    /**
-     * User-scope for the W5 graph lane. Optional because client-side
-     * (single-user) deployments may leave it null; server-side multi-user
-     * deployments must set it so retrieval can filter cross-user IDs.
-     */
-    userId: string | null;
-    createdAt: Date;
-}
-
-/**
- * The recognized entity classifications. Runtime list + derived type kept
- * in one place so the extractor's validation and the `EntityKind` union
- * can't drift apart.
- * @public
+ * @deprecated Use {@link clearAllEncryptionState} instead. This function is kept
+ * as an alias for backwards compatibility and now delegates to the canonical
+ * teardown, which additionally clears `keyAvailableCallbacks`, pending key
+ * requests, and derived ECDH key pairs (both in-memory and persisted).
  */
-declare const ENTITY_KINDS: readonly ["person", "organization", "place", "event", "product", "thing", "concept", "other"];
-/** @public */
-type EntityKind = (typeof ENTITY_KINDS)[number];
-interface StoredEntity {
-    uniqueId: string;
-    canonicalName: string;
-    kind: string | null;
-    createdAt: Date;
-    updatedAt: Date;
-}
+declare function clearAllEncryptionKeys(): void;
 /**
- * Who put a topic on a memory. Written to `memory_vault.topics` but not yet
- * READ anywhere — it exists so a later improvement can refresh the `auto`
- * entries of a curated memory while leaving `user` entries alone (today
- * `topics_user_managed` is all-or-nothing per memory) without needing a second
- * migration or backfill. Don't build that behavior off it yet.
+ * Derives the bytes-native AES key from a raw signature.
  *
- * When you do: a value written by the v42 backfill is NOT ground truth. Pre-v42
- * rows carry no per-topic provenance, so `backfillMemoryTopicsOp` derives it
- * from the per-memory `topics_user_managed` flag and stamps a curated legacy
- * row's every topic `user` — see the note at that derivation.
- * @public
- */
-type TopicSource = "user" | "auto";
-/**
- * One entry in `memory_vault.topics` — the durable, synced record of a memory's
- * topics. `name` carries the CALLER's display casing, unlike
- * {@link StoredEntity.canonicalName}, which {@link normalizeEntityName}
- * lowercases and which has no display column: preserving casing here is the
- * point of storing names on the memory row.
- * @public
+ * Privy Solana `signMessage` returns a `Uint8Array`. Pass those bytes here.
+ * The signature is never hex-encoded, base58-encoded, or passed through
+ * `String()`. That string round-trip is what made {@link hexToBytes} store
+ * zeros for every non-hex pair and yield a low-entropy AES key.
+ *
+ * This is the derivation for the next key version (`anuma-sdk-aes-gcm-v4`).
+ * {@link requestEncryptionKey} does not install it; v2 and v3 stay on the
+ * hex-string path so existing ciphertext keeps decrypting. The return value
+ * is the same 64-char hex form the in-memory store already uses.
+ *
+ * @param signature - Raw signature bytes. Must be at least 64 bytes.
+ * @returns 32-byte AES-GCM key as hex, without a `0x` prefix.
+ * @throws Error when `signature` is shorter than 64 bytes.
+ * @category Encryption
  */
-interface StoredTopic {
-    name: string;
-    kind?: string;
-    source: TopicSource;
-    /** How central the topic is to the memory, in (0, 1]; read it with {@link topicWeight}. */
-    weight?: number;
-}
+declare function deriveKeyFromSignatureBytes(signature: Uint8Array): Promise<string>;
 /**
- * Fixed weight per salience level the topic extractor assigns.
- * @public
+ * Gets the encryption key from in-memory storage and imports it as a CryptoKey.
+ * The key must have been previously requested via requestEncryptionKey.
+ * Uses a cache to avoid re-importing the same key on every call.
+ *
+ * @param address - The wallet address
+ * @param version - Which key version to use (default: "v3" for HKDF key)
+ * @returns The CryptoKey for AES-GCM encryption/decryption
+ * @throws Error if the key hasn't been requested yet
  */
-declare const TOPIC_SALIENCE_WEIGHTS: {
-    readonly primary: 1;
-    readonly secondary: 0.6;
-    readonly mention: 0.3;
-};
-/** @public */
-type TopicSalience = keyof typeof TOPIC_SALIENCE_WEIGHTS;
+declare function getEncryptionKey(address: string, version?: EncryptionKeyVersion): Promise<CryptoKey>;
 /**
- * A topic's weight: 1 when it is user-set or carries no weight.
- * @public
+ * Encrypts data using AES-GCM with the stored encryption key.
+ *
+ * This function uses the encryption key previously generated via `requestEncryptionKey`
+ * to encrypt data. The key must exist in memory before calling this function, or it
+ * will throw an error prompting the user to sign a message.
+ *
+ * @param plaintext - The data to encrypt (string or Uint8Array)
+ * @param address - The wallet address associated with the encryption key
+ * @returns Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @throws Error if encryption key is not found in memory
+ *
+ * @example
+ * ```tsx
+ * import { encryptData, requestEncryptionKey } from "@anuma/sdk/react";
+ *
+ * // First, ensure encryption key exists
+ * await requestEncryptionKey(walletAddress);
+ *
+ * // Then encrypt data
+ * const encrypted = await encryptData("my secret data", walletAddress);
+ * localStorage.setItem("mySecret", encrypted);
+ * ```
+ *
+ * @category Encryption
  */
-declare function topicWeight(topic: StoredTopic): number;
+declare function encryptData(plaintext: string | Uint8Array, address: string): Promise<string>;
 /**
- * The first topic with the highest weight, or null when there are none.
- * @public
+ * Like {@link encryptData} but takes raw bytes and returns the raw encrypted
+ * `[IV][ciphertext+tag]` Uint8Array instead of a hex string. Avoids the hex
+ * round-trip (`encryptData` returns hex, which callers immediately convert back
+ * to bytes) — for large binary media that hex string is a ~1.37x copy of the
+ * whole payload. Use for binary uploads (e.g. enc:v3 media frames).
+ *
+ * @param plaintext - The raw bytes to encrypt
+ * @param address - The wallet address associated with the encryption key
+ * @returns Encrypted data as raw bytes (IV + ciphertext + auth tag)
+ * @category Encryption
  */
-declare function primaryTopic(topics: readonly StoredTopic[] | null | undefined): StoredTopic | null;
-/** @public */
-interface CreateEntityOptions {
-    canonicalName: string;
-    kind?: EntityKind | (string & {});
-}
-
+declare function encryptDataBytes(plaintext: Uint8Array, address: string): Promise<Uint8Array>;
 /**
- * Accepted entity shape for {@link linkMemoryEntitiesOp}. A bare string is
- * a name with no kind (back-compat with the original signature); the object
- * form carries an optional classification.
- * @public
- */
-type EntityInput = string | {
-    name: string;
-    kind?: EntityKind | (string & {});
-    weight?: number;
-};
-interface EntityOperationsContext {
-    database: Database;
-    entityCollection: Collection<Entity>;
-    memoryEntityCollection: Collection<MemoryEntity>;
-    /**
-     * Optional user-scope. When provided, `linkMemoryEntitiesOp` stamps
-     * `user_id` on new memory_entity rows and `getMemoriesByEntityNamesOp`
-     * filters lookups by it. Leave undefined for single-user clients.
-     */
-    userId?: string;
-    /**
-     * When `true`, `getMemoriesByEntityNamesOp` admits rows with
-     * `user_id = null` alongside the strict `userId` match. Set this on
-     * LokiJS (web) adapters where the v31 `unsafeExecuteSql` backfill
-     * is a no-op — pre-v31 rows otherwise become invisible to the W5
-     * lane until `backfillMemoryEntityUserIdsOp` runs. Default `false`
-     * (server / SQLite, where the migration backfill is authoritative).
-     */
-    allowUnscopedRows?: boolean;
-    canWrite?: () => Promise<boolean>;
-}
-/**
- * Link a memory to one or more entities. Accepts bare names (back-compat)
- * or `{ name, kind }` objects. Names are normalized; missing entities are
- * auto-created (with their kind), and an existing entity's null kind is
- * back-filled — see {@link upsertEntitiesInWrite}. Idempotent — duplicate
- * (memory_id, entity_id) pairs are skipped.
+ * Decrypts data using AES-GCM with the stored encryption key.
  *
- * `options.unlessTopicsUserManaged` re-checks the memory's vault row INSIDE
- * the serialized writer and skips link creation when the row is user-managed
- * (`topics_user_managed`), soft-deleted, or absent. Auto paths (extraction,
- * topic worker) need this: a pre-call check races the LLM round-trip —
- * `setMemoryEntitiesOp` sets the flag in its own writer and a delete can land
- * mid-call (orphaning links the cascade already swept) — so only an in-write
- * check guarantees a user's manual edit or delete can't be grafted over. The
- * row read fails CLOSED (skip links) so a transient fault never attaches
- * topics to a memory we couldn't verify. Entity upserts and link creation
- * run in ONE writer to prevent orphan-prune races; returns [] when links
- * were skipped.
+ * This function uses the encryption key previously generated via `requestEncryptionKey`
+ * to decrypt data. The key must exist in memory before calling this function, or it
+ * will throw an error prompting the user to sign a message.
  *
- * `options.topicsSource` (default `auto`) is the provenance recorded in
- * `memory_vault.topics`, which this rewrites from the memory's FULL resulting
- * link set — see {@link prepareTopicsUpdate}. Add semantics mean that set is
- * old ∪ new, so already-linked entities are resolved for their names too.
+ * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @param address - The wallet address associated with the encryption key
+ * @returns Decrypted data as string
+ * @throws Error if encryption key is not found in memory or if decryption fails
  *
- * @deprecated App code: use `MemoryStore.addTopics` (`createLocalMemoryStore`).
- */
-declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>, options?: {
-    unlessTopicsUserManaged?: boolean;
-    topicsSource?: TopicSource;
-}): Promise<StoredEntity[]>;
-/**
- * REPLACE a memory's entity links with an auto-derived set — the topic
- * worker's write primitive. Unlike {@link setMemoryEntitiesOp} it does NOT
- * mark the memory user-managed (the pass is automatic), and unlike
- * {@link linkMemoryEntitiesOp} it removes stale links, so re-extracting an
- * edited memory drops entities its previous content mentioned ("works at
- * Acme" → "works at Globex" must unlink Acme). Insert-missing and
- * destroy-stale are batched in ONE writer, after the same in-write guard as
- * the link op (user-managed / deleted / absent / read-fault ⇒ skip).
+ * @example
+ * ```tsx
+ * import { decryptData, requestEncryptionKey } from "@anuma/sdk/react";
  *
- * That batch also prunes `entity` rows left with no links at all (see
- * {@link findOrphanedEntities}) — otherwise a topic the extractor has disowned
- * keeps rendering as a chip that matches no memory.
+ * // First, ensure encryption key exists
+ * await requestEncryptionKey(walletAddress);
  *
- * Returns the linked entities ([] for an answered-empty set), or null when
- * the guard skipped — callers must treat null as "not persisted" (e.g. don't
- * stamp `topics_extracted_at`).
+ * // Then decrypt data
+ * const encrypted = localStorage.getItem("mySecret");
+ * if (encrypted) {
+ *   const decrypted = await decryptData(encrypted, walletAddress);
+ *   console.log("Decrypted:", decrypted);
+ * }
+ * ```
+ *
+ * @category Encryption
  */
-declare function replaceMemoryEntitiesGuardedOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>): Promise<StoredEntity[] | null>;
+declare function decryptData(encryptedHex: string, address: string, version?: EncryptionKeyVersion): Promise<string>;
 /**
- * Backfill `memory_entity.user_id` from the parent vault row's user_id.
- * Idempotent — only touches rows where user_id is null.
- *
- * Why this exists: the v31 schema migration backfills via
- * `unsafeExecuteSql`, which is a no-op on the LokiJS (web) adapter. Native
- * SQLite installs have already been filled by the migration; web installs
- * upgrading through v31 keep `user_id=null` on every pre-existing
- * `memory_entity` row until this helper runs.
+ * Decrypts data and returns as Uint8Array (for binary data)
+ * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @returns Decrypted data as Uint8Array
+ */
+declare function decryptDataBytes(encryptedHex: string, address: string, version?: EncryptionKeyVersion): Promise<Uint8Array>;
+/**
+ * Like {@link decryptDataBytes} but takes the raw encrypted bytes
+ * (`[IV][ciphertext+tag]`) directly instead of a hex string. Skips the
+ * `hexToBytes` conversion — for large binary media the hex string the caller
+ * would otherwise build is a ~1.37x copy of the whole payload (a ~1GB string
+ * for a 500MB video), plus this avoids a second byte copy. Same key resolution
+ * as decryptDataBytes.
  *
- * Consumers wiring an `EntityOperationsContext` with `userId` set are
- * obliged to call this once on first use — `getMemoriesByEntityNamesOp`
- * strictly filters by `user_id`, so unstamped rows are otherwise
- * invisible to the W5 graph lane.
+ * @param encrypted - Raw encrypted bytes (IV + ciphertext + auth tag), no hex
+ * @param address - The wallet address associated with the encryption key
+ * @param version - Encryption key version to decrypt with (defaults to "v3")
+ * @returns Decrypted data as Uint8Array
+ * @category Encryption
+ */
+declare function decryptDataBytesFromBytes(encrypted: Uint8Array, address: string, version?: EncryptionKeyVersion): Promise<Uint8Array>;
+/**
+ * Checks if an encryption key exists in memory for the given wallet address.
  *
- * @public
+ * @param address - Wallet address
+ * @param version - When omitted, checks the **v3** (`current`) key — the key
+ *   write/OPFS/encrypt paths need. Callers that only need to read legacy
+ *   `enc:v2:` data should pass `"v2"` explicitly. (#561 / PR #828)
  */
-declare function backfillMemoryEntityUserIdsOp(ctx: EntityOperationsContext, vaultMemoryCollection: {
-    find: (id: string) => Promise<{
-        userId?: string | null;
-    }>;
-}): Promise<number>;
+declare function hasEncryptionKey(address: string, version?: EncryptionKeyVersion): boolean;
 /**
- * W5 graph-lane read: given a set of entity names (e.g. extracted from
- * a query), return the set of memory IDs linked to *any* of them, with
- * a per-memory count of how many of the queried entities they match.
+ * Seed (or merge) raw key hex into the in-memory store without signing.
  *
- * Caller passes the result to `rankByEntityOverlap` to score each
- * memory via `tanh(0.5 × shared_entity_count)` — this op only does the
- * cheap "find candidate memories" step and leaves scoring to the
- * ranker so callers can attach their own kind-weights or alternative
- * scoring strategies later.
+ * Used by platform polyfills that hydrate from SecureStore / keychain where
+ * one version may be missing — callers must not require both versions to
+ * exist before the other becomes usable (#561).
  *
- * Names are normalized (lowercased, trimmed). Empty input returns an
- * empty map. Names that don't exist as entities contribute nothing.
+ * Existing versions are preserved when the corresponding argument is omitted.
+ * Pass an explicit empty merge is not supported; omit the field to leave it.
  *
- * Multi-user safety: when `ctx.userId` is set, results are filtered to
- * memory_entity rows whose `user_id` matches. Without this filter the
- * lane returns IDs from every user who tagged a matching entity.
+ * Each provided key must be 64 hex characters (32-byte AES key).
+ */
+declare function seedEncryptionKeys(address: string, keys: {
+    legacy?: string;
+    current?: string;
+}): void;
+/**
+ * Encrypts data using a pre-fetched CryptoKey.
+ * Use this for batch operations to avoid repeated key lookups.
  *
- * @deprecated App code: use `MemoryStore.memoriesByTopics` (`createLocalMemoryStore`).
+ * @param plaintext - The data to encrypt (string or Uint8Array)
+ * @param key - The CryptoKey for AES-GCM encryption
+ * @returns Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @internal
  */
-declare function getMemoriesByEntityNamesOp(ctx: EntityOperationsContext, entityNames: readonly string[]): Promise<Map<string, Set<string>>>;
+declare function encryptDataWithKey(plaintext: string | Uint8Array, key: CryptoKey): Promise<string>;
 /**
- * Reverse of {@link getMemoriesByEntityNamesOp}: given a set of memory IDs
- * (e.g. the current BFS frontier), return each memory's set of linked
- * canonical entity names. This is the missing primitive for multi-hop graph
- * traversal (PR4) — one step outward from a memory to its neighbor entities,
- * which the traversal then expands to reach topically-adjacent memories.
+ * Decrypts data using a pre-fetched CryptoKey.
+ * Use this for batch operations to avoid repeated key lookups.
  *
- * Empty input returns an empty map. Memory IDs with no links contribute
- * nothing (they simply don't appear as keys).
+ * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
+ * @param key - The CryptoKey for AES-GCM decryption
+ * @returns Decrypted data as string
+ * @internal
+ */
+declare function decryptDataWithKey(encryptedHex: string, key: CryptoKey): Promise<string>;
+/**
+ * Batch encrypt multiple values efficiently with a single key lookup.
+ * Much faster than calling encryptData for each value individually.
  *
- * Multi-user safety mirrors {@link getMemoriesByEntityNamesOp} exactly: when
- * `ctx.userId` is set, only `memory_entity` rows owned by that user are
- * followed (with the same `allowUnscopedRows` LokiJS escape hatch for pre-v31
- * rows whose `user_id` backfill was a no-op). Without the filter the reverse
- * lookup would leak entity links written by other users.
+ * @param values - Array of plaintext values to encrypt
+ * @param address - The wallet address associated with the encryption key
+ * @returns Array of encrypted values as hex strings
+ * @throws Error if encryption key is not found in memory
  *
- * @public
+ * @example
+ * ```tsx
+ * const encrypted = await encryptDataBatch(
+ *   ["secret1", "secret2", "secret3"],
+ *   walletAddress
+ * );
+ * ```
  *
- * @deprecated App code: use `MemoryStore.topicsByMemories` (`createLocalMemoryStore`).
+ * @category Encryption
  */
-declare function getEntitiesByMemoryIdsOp(ctx: EntityOperationsContext, memoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
-
+declare function encryptDataBatch(values: (string | Uint8Array)[], address: string): Promise<string[]>;
 /**
- * Encryption key version type.
- * - "v2": Legacy SHA-256 derived key (for reading enc:v2: data)
- * - "v3": HKDF derived key with domain separation (for new encryption)
+ * Batch decrypt multiple values efficiently with a single key lookup.
+ * Much faster than calling decryptData for each value individually.
  *
- * Raw signature bytes (Privy Solana `signMessage` returns a `Uint8Array`) are
- * not a stored version. Derive them with {@link deriveKeyFromSignatureBytes}.
- * {@link requestEncryptionKey} still derives v2 and v3 from a hex signature only.
+ * @param encryptedValues - Array of encrypted hex strings
+ * @param address - The wallet address associated with the encryption key
+ * @returns Array of decrypted plaintext values
+ * @throws Error if encryption key is not found in memory or decryption fails
+ *
+ * @example
+ * ```tsx
+ * const decrypted = await decryptDataBatch(
+ *   [encrypted1, encrypted2, encrypted3],
+ *   walletAddress
+ * );
+ * ```
+ *
+ * @category Encryption
  */
-type EncryptionKeyVersion = "v2" | "v3";
+declare function decryptDataBatch(encryptedValues: string[], address: string): Promise<string[]>;
 /**
- * Thrown by {@link getEncryptionKey} when the requested version is absent.
- * Distinct from AES-GCM auth-tag failures so decrypt callers can tell
- * "need to derive/hydrate this version" from "wrong key for intact ciphertext".
+ * Options for signing messages.
  */
-declare class EncryptionKeyMissingError extends Error {
-    readonly address: string;
-    readonly version: EncryptionKeyVersion;
-    constructor(address: string, version: EncryptionKeyVersion);
+interface SignMessageOptions {
+    /** Whether to show wallet UI during signing. Default: true */
+    showWalletUIs?: boolean;
 }
 /**
- * Options for {@link requestEncryptionKey}.
- */
-interface RequestEncryptionKeyOptions {
-    /**
-     * When true, re-derive and replace any existing in-memory keys for this
-     * address. Default false preserves the historical "if present, return"
-     * short-circuit. Prefer {@link refreshEncryptionKeyIfMatches} when the
-     * caller has ciphertext that must keep working — force-replace can pin a
-     * newly derived wrong key over a still-valid one.
-     */
-    force?: boolean;
-}
-/**
- * Register a callback that fires when an encryption key becomes available for an address.
- * If the key is already available, the callback fires immediately.
- * @returns Unsubscribe function
+ * Type for the signMessage function that client must provide.
+ * This is typically from Privy's useSignMessage hook.
+ *
+ * The resolved value must be a hex signature (`0x`-prefixed or bare). A
+ * non-hex string — including `String(uint8Array)` or a base58 signature —
+ * throws from key derivation instead of becoming a zero-filled AES key.
+ * Raw signature bytes go to {@link deriveKeyFromSignatureBytes}.
  */
-declare function onKeyAvailable(address: string, callback: () => void): () => void;
+type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
- * Clears the encryption key for a wallet address from memory
- * @param address - The wallet address
+ * Type for embedded wallet signer function that enables silent signing.
+ * For Privy embedded wallets, this can sign programmatically without user interaction
+ * when configured correctly in the Privy dashboard.
  */
-declare function clearEncryptionKey(address: string): void;
+type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
- * Clears all encryption-related state from memory and any derived persistence.
- *
- * This is the canonical session-teardown entry point. It wipes every module-level
- * map that retains key material or listeners tied to a session: the raw
- * encryption keys, cached imported CryptoKey objects, availability callbacks,
- * pending sign-in flights, and derived ECDH key pairs. It also removes any
- * persisted ECDH key pairs from localStorage so they can't be decrypted by a
- * subsequent user on a shared browser.
+ * Requests the user to sign a message to generate an encryption key.
+ * If a key already exists in memory for the given wallet, resolves immediately
+ * unless {@link RequestEncryptionKeyOptions.force} is set.
  *
- * Call this on logout / session-end to prevent cross-user key leakage on shared
- * browsers. If you manage auth outside the SDK, wire this into your logout flow.
+ * Note: Keys are stored in memory only and do not persist across page reloads.
+ * This is a security feature - users must sign once per session to derive their key.
  *
- * @example
- * ```tsx
- * import { clearAllEncryptionState } from "@anuma/sdk/react";
+ * When a seeded/pinned store already has keys and the fresh derive does not
+ * match any of them, the store is left unchanged and this resolves to `false`
+ * (without firing {@link onKeyAvailable}). Callers that need write readiness
+ * should check the return value or {@link hasEncryptionKey} before encrypting
+ * so they can surface a re-unlock UI instead of failing downstream (#828).
  *
- * async function handleLogout() {
- *   clearAllEncryptionState();
- *   await privy.logout();
- * }
- * ```
+ * @param walletAddress - The wallet address to generate the key for
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @param options - Optional flags (e.g. force re-derive)
+ * @returns `true` when keys are available after the call; `false` when a
+ *   divergent derive left the store unchanged (or the session was torn down
+ *   mid-flight).
  */
-declare function clearAllEncryptionState(): void;
+declare function requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn, options?: RequestEncryptionKeyOptions): Promise<boolean>;
 /**
- * Clears all encryption keys from memory.
+ * Re-derive encryption keys from a fresh signature and commit them **only if**
+ * they successfully decrypt `probeCiphertext` (a prefixed `enc:v2:` / `enc:v3:`
+ * value). If they do not, the existing in-memory keys are left untouched.
  *
- * @deprecated Use {@link clearAllEncryptionState} instead. This function is kept
- * as an alias for backwards compatibility and now delegates to the canonical
- * teardown, which additionally clears `keyAvailableCallbacks`, pending key
- * requests, and derived ECDH key pairs (both in-memory and persisted).
+ * Concurrent calls for the same wallet share one sign+derive. Each caller then
+ * probes **its own** ciphertext against those candidates, so mixed-era messages
+ * in one `Promise.all` batch can still recover when only the leader's probe
+ * misses (#828 review). Failed candidates are memoized for the session so
+ * pagination does not re-prompt on every page when the wallet has changed.
+ *
+ * @returns true when keys were refreshed (probe decrypted); false when the
+ *   probe failed under the candidate keys (store unchanged) or the probe was
+ *   not encrypted.
  */
-declare function clearAllEncryptionKeys(): void;
+declare function refreshEncryptionKeyIfMatches(walletAddress: string, probeCiphertext: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<boolean>;
 /**
- * Derives the bytes-native AES key from a raw signature.
- *
- * Privy Solana `signMessage` returns a `Uint8Array`. Pass those bytes here.
- * The signature is never hex-encoded, base58-encoded, or passed through
- * `String()`. That string round-trip is what made {@link hexToBytes} store
- * zeros for every non-hex pair and yield a low-entropy AES key.
+ * Requests the user to sign a message to generate an ECDH key pair.
+ * If a key pair already exists in memory for the given wallet, resolves immediately.
  *
- * This is the derivation for the next key version (`anuma-sdk-aes-gcm-v4`).
- * {@link requestEncryptionKey} does not install it; v2 and v3 stay on the
- * hex-string path so existing ciphertext keeps decrypting. The return value
- * is the same 64-char hex form the in-memory store already uses.
+ * Note: Key pairs are stored in memory only and do not persist across page reloads.
+ * This is a security feature - users must sign once per session to derive their key pair.
  *
- * @param signature - Raw signature bytes. Must be at least 64 bytes.
- * @returns 32-byte AES-GCM key as hex, without a `0x` prefix.
- * @throws Error when `signature` is shorter than 64 bytes.
- * @category Encryption
+ * @param walletAddress - The wallet address to generate the key pair for
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @returns Promise that resolves when the key pair is available
  */
-declare function deriveKeyFromSignatureBytes(signature: Uint8Array): Promise<string>;
+declare function requestKeyPair(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<void>;
 /**
- * Gets the encryption key from in-memory storage and imports it as a CryptoKey.
- * The key must have been previously requested via requestEncryptionKey.
- * Uses a cache to avoid re-importing the same key on every call.
- *
+ * Exports the public key for a wallet address as SPKI format (base64)
  * @param address - The wallet address
- * @param version - Which key version to use (default: "v3" for HKDF key)
- * @returns The CryptoKey for AES-GCM encryption/decryption
- * @throws Error if the key hasn't been requested yet
+ * @param signMessage - Function to sign a message (returns signature hex string)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @returns The public key as base64-encoded SPKI string
  */
-declare function getEncryptionKey(address: string, version?: EncryptionKeyVersion): Promise<CryptoKey>;
+declare function exportPublicKey(address: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<string>;
 /**
- * Encrypts data using AES-GCM with the stored encryption key.
+ * Checks if a key pair exists in memory for the given wallet address
+ * @param address - The wallet address
+ * @returns True if key pair exists, false otherwise
+ */
+declare function hasKeyPair(address: string): boolean;
+/**
+ * Clears the key pair for a wallet address from memory and localStorage
+ * @param address - The wallet address
+ */
+declare function clearKeyPair(address: string): void;
+/**
+ * Clears all key pairs from memory and any persisted entries in localStorage.
  *
- * This function uses the encryption key previously generated via `requestEncryptionKey`
- * to encrypt data. The key must exist in memory before calling this function, or it
- * will throw an error prompting the user to sign a message.
+ * Matches the persistence behavior of the per-address {@link clearKeyPair};
+ * without this, `clearAllKeyPairs()` would leave `ecdh_keypair_*` ciphertext
+ * behind in storage while `clearKeyPair(address)` removes it.
+ */
+declare function clearAllKeyPairs(): void;
+/**
+ * Result returned by the useEncryption hook.
+ * @category Hooks
+ */
+interface UseEncryptionResult {
+    /** Request and generate an encryption key for a wallet address */
+    requestEncryptionKey: (walletAddress: string) => Promise<boolean>;
+    /** Request and generate an ECDH key pair for a wallet address */
+    requestKeyPair: (walletAddress: string) => Promise<void>;
+    /** Export the public key for a wallet address as base64-encoded SPKI */
+    exportPublicKey: (walletAddress: string) => Promise<string>;
+    /** Check if a key pair exists in memory for a wallet address */
+    hasKeyPair: (walletAddress: string) => boolean;
+    /** Clear the key pair for a wallet address from memory */
+    clearKeyPair: (walletAddress: string) => void;
+}
+/**
+ * Hook that provides encryption key management for securing local data.
  *
- * @param plaintext - The data to encrypt (string or Uint8Array)
- * @param address - The wallet address associated with the encryption key
- * @returns Encrypted data as hex string (IV + ciphertext + auth tag)
- * @throws Error if encryption key is not found in memory
+ * This hook helps you encrypt and decrypt data using a key derived from a wallet
+ * signature. It requires `@privy-io/react-auth` for wallet authentication. Keys are
+ * stored in memory only and do not persist across page reloads for security.
  *
- * @example
- * ```tsx
- * import { encryptData, requestEncryptionKey } from "@anuma/sdk/react";
+ * ## How it works
  *
- * // First, ensure encryption key exists
- * await requestEncryptionKey(walletAddress);
+ * 1. User signs a message with their wallet
+ * 2. The signature is used to deterministically derive an encryption key
+ * 3. The key is stored in memory (not localStorage) for the session
+ * 4. Data can be encrypted/decrypted using this key
+ * 5. On page reload, user must sign again to derive the key
  *
- * // Then encrypt data
- * const encrypted = await encryptData("my secret data", walletAddress);
- * localStorage.setItem("mySecret", encrypted);
- * ```
+ * ## Security Features
  *
- * @category Encryption
- */
-declare function encryptData(plaintext: string | Uint8Array, address: string): Promise<string>;
-/**
- * Like {@link encryptData} but takes raw bytes and returns the raw encrypted
- * `[IV][ciphertext+tag]` Uint8Array instead of a hex string. Avoids the hex
- * round-trip (`encryptData` returns hex, which callers immediately convert back
- * to bytes) — for large binary media that hex string is a ~1.37x copy of the
- * whole payload. Use for binary uploads (e.g. enc:v3 media frames).
+ * - **In-memory only**: Keys never touch disk or localStorage
+ * - **Deterministic**: Same wallet + signature always generates same key
+ * - **Session-scoped**: Keys cleared on page reload
+ * - **XSS-resistant**: Keys not accessible after page reload
  *
- * @param plaintext - The raw bytes to encrypt
- * @param address - The wallet address associated with the encryption key
- * @returns Encrypted data as raw bytes (IV + ciphertext + auth tag)
- * @category Encryption
- */
-declare function encryptDataBytes(plaintext: Uint8Array, address: string): Promise<Uint8Array>;
-/**
- * Decrypts data using AES-GCM with the stored encryption key.
+ * ## Embedded Wallet Support
  *
- * This function uses the encryption key previously generated via `requestEncryptionKey`
- * to decrypt data. The key must exist in memory before calling this function, or it
- * will throw an error prompting the user to sign a message.
+ * For Privy embedded wallets, you can provide an `embeddedWalletSigner` function
+ * to enable silent signing without user confirmation modals. This is useful for
+ * deterministic key generation that should happen automatically.
  *
- * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
- * @param address - The wallet address associated with the encryption key
- * @returns Decrypted data as string
- * @throws Error if encryption key is not found in memory or if decryption fails
+ * @param signMessage - Function to sign a message (from Privy's useSignMessage hook)
+ * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
+ * @returns Functions to request encryption keys and manage key pairs
  *
  * @example
  * ```tsx
- * import { decryptData, requestEncryptionKey } from "@anuma/sdk/react";
+ * import { usePrivy, useWallets } from "@privy-io/react-auth";
+ * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
  *
- * // First, ensure encryption key exists
- * await requestEncryptionKey(walletAddress);
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { wallets } = useWallets();
+ *   const embeddedWallet = wallets.find(w => w.walletClientType === 'privy');
  *
- * // Then decrypt data
- * const encrypted = localStorage.getItem("mySecret");
- * if (encrypted) {
- *   const decrypted = await decryptData(encrypted, walletAddress);
- *   console.log("Decrypted:", decrypted);
- * }
- * ```
+ *   // Create silent signer for embedded wallets
+ *   const embeddedSigner = useCallback(async (message: string) => {
+ *     if (embeddedWallet) {
+ *       const { signature } = await embeddedWallet.signMessage({ message });
+ *       return signature;
+ *     }
+ *     throw new Error('No embedded wallet');
+ *   }, [embeddedWallet]);
  *
- * @category Encryption
- */
-declare function decryptData(encryptedHex: string, address: string, version?: EncryptionKeyVersion): Promise<string>;
-/**
- * Decrypts data and returns as Uint8Array (for binary data)
- * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
- * @returns Decrypted data as Uint8Array
- */
-declare function decryptDataBytes(encryptedHex: string, address: string, version?: EncryptionKeyVersion): Promise<Uint8Array>;
-/**
- * Like {@link decryptDataBytes} but takes the raw encrypted bytes
- * (`[IV][ciphertext+tag]`) directly instead of a hex string. Skips the
- * `hexToBytes` conversion — for large binary media the hex string the caller
- * would otherwise build is a ~1.37x copy of the whole payload (a ~1GB string
- * for a 500MB video), plus this avoids a second byte copy. Same key resolution
- * as decryptDataBytes.
- *
- * @param encrypted - Raw encrypted bytes (IV + ciphertext + auth tag), no hex
- * @param address - The wallet address associated with the encryption key
- * @param version - Encryption key version to decrypt with (defaults to "v3")
- * @returns Decrypted data as Uint8Array
- * @category Encryption
- */
-declare function decryptDataBytesFromBytes(encrypted: Uint8Array, address: string, version?: EncryptionKeyVersion): Promise<Uint8Array>;
-/**
- * Checks if an encryption key exists in memory for the given wallet address.
- *
- * @param address - Wallet address
- * @param version - When omitted, checks the **v3** (`current`) key — the key
- *   write/OPFS/encrypt paths need. Callers that only need to read legacy
- *   `enc:v2:` data should pass `"v2"` explicitly. (#561 / PR #828)
- */
-declare function hasEncryptionKey(address: string, version?: EncryptionKeyVersion): boolean;
-/**
- * Seed (or merge) raw key hex into the in-memory store without signing.
- *
- * Used by platform polyfills that hydrate from SecureStore / keychain where
- * one version may be missing — callers must not require both versions to
- * exist before the other becomes usable (#561).
- *
- * Existing versions are preserved when the corresponding argument is omitted.
- * Pass an explicit empty merge is not supported; omit the field to leave it.
+ *   const { requestEncryptionKey } = useEncryption(signMessage, embeddedSigner);
  *
- * Each provided key must be 64 hex characters (32-byte AES key).
- */
-declare function seedEncryptionKeys(address: string, keys: {
-    legacy?: string;
-    current?: string;
-}): void;
-/**
- * Encrypts data using a pre-fetched CryptoKey.
- * Use this for batch operations to avoid repeated key lookups.
+ *   // Request encryption key when user is authenticated
+ *   useEffect(() => {
+ *     if (user?.wallet?.address) {
+ *       // This will use silent signing for embedded wallets
+ *       await requestEncryptionKey(user.wallet.address);
+ *     }
+ *   }, [user]);
  *
- * @param plaintext - The data to encrypt (string or Uint8Array)
- * @param key - The CryptoKey for AES-GCM encryption
- * @returns Encrypted data as hex string (IV + ciphertext + auth tag)
- * @internal
- */
-declare function encryptDataWithKey(plaintext: string | Uint8Array, key: CryptoKey): Promise<string>;
-/**
- * Decrypts data using a pre-fetched CryptoKey.
- * Use this for batch operations to avoid repeated key lookups.
+ *   // Encrypt data
+ *   const saveSecret = async (text: string) => {
+ *     const encrypted = await encryptData(text, user.wallet.address);
+ *     localStorage.setItem("mySecret", encrypted);
+ *   };
  *
- * @param encryptedHex - Encrypted data as hex string (IV + ciphertext + auth tag)
- * @param key - The CryptoKey for AES-GCM decryption
- * @returns Decrypted data as string
- * @internal
- */
-declare function decryptDataWithKey(encryptedHex: string, key: CryptoKey): Promise<string>;
-/**
- * Batch encrypt multiple values efficiently with a single key lookup.
- * Much faster than calling encryptData for each value individually.
+ *   // Decrypt data
+ *   const loadSecret = async () => {
+ *     const encrypted = localStorage.getItem("mySecret");
+ *     if (encrypted) {
+ *       const decrypted = await decryptData(encrypted, user.wallet.address);
+ *       console.log(decrypted);
+ *     }
+ *   };
  *
- * @param values - Array of plaintext values to encrypt
- * @param address - The wallet address associated with the encryption key
- * @returns Array of encrypted values as hex strings
- * @throws Error if encryption key is not found in memory
+ *   return (
+ *     <div>
+ *       <button onClick={() => saveSecret("my secret data")}>Encrypt & Save</button>
+ *       <button onClick={loadSecret}>Load & Decrypt</button>
+ *     </div>
+ *   );
+ * }
+ * ```
  *
  * @example
  * ```tsx
- * const encrypted = await encryptDataBatch(
- *   ["secret1", "secret2", "secret3"],
- *   walletAddress
- * );
- * ```
+ * // Standard usage with external wallets (shows confirmation modal)
+ * import { usePrivy } from "@privy-io/react-auth";
+ * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
  *
- * @category Encryption
- */
-declare function encryptDataBatch(values: (string | Uint8Array)[], address: string): Promise<string[]>;
-/**
- * Batch decrypt multiple values efficiently with a single key lookup.
- * Much faster than calling decryptData for each value individually.
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { requestEncryptionKey } = useEncryption(signMessage);
  *
- * @param encryptedValues - Array of encrypted hex strings
- * @param address - The wallet address associated with the encryption key
- * @returns Array of decrypted plaintext values
- * @throws Error if encryption key is not found in memory or decryption fails
+ *   // Request encryption key when user is authenticated
+ *   useEffect(() => {
+ *     if (user?.wallet?.address) {
+ *       // This will prompt user to sign if key doesn't exist
+ *       await requestEncryptionKey(user.wallet.address);
+ *     }
+ *   }, [user]);
+ * }
+ * ```
  *
  * @example
  * ```tsx
- * const decrypted = await decryptDataBatch(
- *   [encrypted1, encrypted2, encrypted3],
- *   walletAddress
- * );
- * ```
- *
- * @category Encryption
- */
-declare function decryptDataBatch(encryptedValues: string[], address: string): Promise<string[]>;
-/**
- * Options for signing messages.
- */
-interface SignMessageOptions {
-    /** Whether to show wallet UI during signing. Default: true */
-    showWalletUIs?: boolean;
-}
-/**
- * Type for the signMessage function that client must provide.
- * This is typically from Privy's useSignMessage hook.
- *
- * The resolved value must be a hex signature (`0x`-prefixed or bare). A
- * non-hex string — including `String(uint8Array)` or a base58 signature —
- * throws from key derivation instead of becoming a zero-filled AES key.
- * Raw signature bytes go to {@link deriveKeyFromSignatureBytes}.
- */
-type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
-/**
- * Type for embedded wallet signer function that enables silent signing.
- * For Privy embedded wallets, this can sign programmatically without user interaction
- * when configured correctly in the Privy dashboard.
- */
-type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
-/**
- * Requests the user to sign a message to generate an encryption key.
- * If a key already exists in memory for the given wallet, resolves immediately
- * unless {@link RequestEncryptionKeyOptions.force} is set.
- *
- * Note: Keys are stored in memory only and do not persist across page reloads.
- * This is a security feature - users must sign once per session to derive their key.
- *
- * When a seeded/pinned store already has keys and the fresh derive does not
- * match any of them, the store is left unchanged and this resolves to `false`
- * (without firing {@link onKeyAvailable}). Callers that need write readiness
- * should check the return value or {@link hasEncryptionKey} before encrypting
- * so they can surface a re-unlock UI instead of failing downstream (#828).
- *
- * @param walletAddress - The wallet address to generate the key for
- * @param signMessage - Function to sign a message (returns signature hex string)
- * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
- * @param options - Optional flags (e.g. force re-derive)
- * @returns `true` when keys are available after the call; `false` when a
- *   divergent derive left the store unchanged (or the session was torn down
- *   mid-flight).
- */
-declare function requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn, options?: RequestEncryptionKeyOptions): Promise<boolean>;
-/**
- * Re-derive encryption keys from a fresh signature and commit them **only if**
- * they successfully decrypt `probeCiphertext` (a prefixed `enc:v2:` / `enc:v3:`
- * value). If they do not, the existing in-memory keys are left untouched.
- *
- * Concurrent calls for the same wallet share one sign+derive. Each caller then
- * probes **its own** ciphertext against those candidates, so mixed-era messages
- * in one `Promise.all` batch can still recover when only the leader's probe
- * misses (#828 review). Failed candidates are memoized for the session so
- * pagination does not re-prompt on every page when the wallet has changed.
+ * // ECDH key pair generation for end-to-end encryption
+ * import { usePrivy } from "@privy-io/react-auth";
+ * import { useEncryption } from "@anuma/sdk/react";
  *
- * @returns true when keys were refreshed (probe decrypted); false when the
- *   probe failed under the candidate keys (store unchanged) or the probe was
- *   not encrypted.
- */
-declare function refreshEncryptionKeyIfMatches(walletAddress: string, probeCiphertext: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<boolean>;
-/**
- * Requests the user to sign a message to generate an ECDH key pair.
- * If a key pair already exists in memory for the given wallet, resolves immediately.
+ * function E2EEComponent() {
+ *   const { signMessage } = usePrivy();
+ *   const { requestKeyPair, exportPublicKey } = useEncryption(signMessage);
  *
- * Note: Key pairs are stored in memory only and do not persist across page reloads.
- * This is a security feature - users must sign once per session to derive their key pair.
+ *   const setupEncryption = async (walletAddress: string) => {
+ *     // Generate deterministic ECDH key pair from wallet signature
+ *     await requestKeyPair(walletAddress);
  *
- * @param walletAddress - The wallet address to generate the key pair for
- * @param signMessage - Function to sign a message (returns signature hex string)
- * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
- * @returns Promise that resolves when the key pair is available
- */
-declare function requestKeyPair(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<void>;
-/**
- * Exports the public key for a wallet address as SPKI format (base64)
- * @param address - The wallet address
- * @param signMessage - Function to sign a message (returns signature hex string)
- * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
- * @returns The public key as base64-encoded SPKI string
- */
-declare function exportPublicKey(address: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<string>;
-/**
- * Checks if a key pair exists in memory for the given wallet address
- * @param address - The wallet address
- * @returns True if key pair exists, false otherwise
- */
-declare function hasKeyPair(address: string): boolean;
-/**
- * Clears the key pair for a wallet address from memory and localStorage
- * @param address - The wallet address
- */
-declare function clearKeyPair(address: string): void;
-/**
- * Clears all key pairs from memory and any persisted entries in localStorage.
+ *     // Export public key to share with others
+ *     const publicKey = await exportPublicKey(walletAddress);
+ *     console.log("Share this public key:", publicKey);
+ *   };
+ * }
+ * ```
  *
- * Matches the persistence behavior of the per-address {@link clearKeyPair};
- * without this, `clearAllKeyPairs()` would leave `ecdh_keypair_*` ciphertext
- * behind in storage while `clearKeyPair(address)` removes it.
- */
-declare function clearAllKeyPairs(): void;
-/**
- * Result returned by the useEncryption hook.
  * @category Hooks
  */
-interface UseEncryptionResult {
-    /** Request and generate an encryption key for a wallet address */
-    requestEncryptionKey: (walletAddress: string) => Promise<boolean>;
-    /** Request and generate an ECDH key pair for a wallet address */
-    requestKeyPair: (walletAddress: string) => Promise<void>;
-    /** Export the public key for a wallet address as base64-encoded SPKI */
-    exportPublicKey: (walletAddress: string) => Promise<string>;
-    /** Check if a key pair exists in memory for a wallet address */
-    hasKeyPair: (walletAddress: string) => boolean;
-    /** Clear the key pair for a wallet address from memory */
-    clearKeyPair: (walletAddress: string) => void;
-}
-/**
- * Hook that provides encryption key management for securing local data.
- *
- * This hook helps you encrypt and decrypt data using a key derived from a wallet
- * signature. It requires `@privy-io/react-auth` for wallet authentication. Keys are
- * stored in memory only and do not persist across page reloads for security.
- *
- * ## How it works
- *
- * 1. User signs a message with their wallet
- * 2. The signature is used to deterministically derive an encryption key
- * 3. The key is stored in memory (not localStorage) for the session
- * 4. Data can be encrypted/decrypted using this key
- * 5. On page reload, user must sign again to derive the key
- *
- * ## Security Features
- *
- * - **In-memory only**: Keys never touch disk or localStorage
- * - **Deterministic**: Same wallet + signature always generates same key
- * - **Session-scoped**: Keys cleared on page reload
- * - **XSS-resistant**: Keys not accessible after page reload
- *
- * ## Embedded Wallet Support
+declare function useEncryption(signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): UseEncryptionResult;
+
+type ChatRecordKind = "conversation" | "message" | "summary" | "project" | "memory_links";
+type ChatJson = null | boolean | number | string | ChatJson[] | {
+    [key: string]: ChatJson;
+};
+/** Whole-record JSON data is encrypted on the device, including all text, vectors and tool events. */
+interface ChatRecord {
+    kind: ChatRecordKind;
+    id: string;
+    conversationId: string;
+    sortKey: number;
+    createdAt: number;
+    updatedAt: number;
+    isDeleted: boolean;
+    data: {
+        [key: string]: ChatJson;
+    };
+}
+interface ChatSnapshot {
+    record: ChatRecord;
+    version: number;
+    serverUpdatedAt: string;
+}
+interface ChatWrite {
+    record: ChatRecord;
+    expectedVersion: number;
+    /** Sent and stored unencrypted so vault can run vector search. */
+    embeddings?: number[][];
+    embeddingModel?: string;
+}
+interface ChatRef {
+    kind: ChatRecordKind;
+    id: string;
+}
+type ChatAccountState = "none" | "migrating" | "active";
+interface ChatAccount {
+    keyId: string;
+    state: ChatAccountState;
+    recordCount: number;
+    storageBytes: number;
+    vectorCount: number;
+    /** The newest change; read it before loading history and poll `changes` from it. Absent before the first record. */
+    changesCursor?: string;
+}
+interface ChatImport {
+    record: ChatRecord;
+    /** Sent and stored unencrypted so vault can run vector search. */
+    embeddings?: number[][];
+    embeddingModel?: string;
+}
+interface ChatRevision {
+    kind: ChatRecordKind;
+    id: string;
+    updatedAt: number;
+    isDeleted: boolean;
+}
+interface ChatChanges {
+    items: ChatSnapshot[];
+    nextCursor?: string;
+    changesCursor: string;
+}
+interface ChatSearchOptions {
+    limit?: number;
+    kinds?: ("message" | "summary")[];
+    conversationId?: string;
+    excludeConversationId?: string;
+    /** Ranks only vectors from this model; vectors stored without one always count. */
+    embeddingModel?: string;
+    signal?: AbortSignal;
+}
+interface ChatSearchHit extends ChatSnapshot {
+    chunk: number;
+    score: number;
+}
+interface ChatAttachment {
+    id: string;
+    sizeBytes: number;
+    state: "pending" | "committed";
+    ownerKind?: "message" | "summary";
+    ownerId?: string;
+    createdAt: string;
+    committedAt?: string;
+}
+interface ChatPresignedUrl {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    expiresAt: string;
+}
+interface ChatAttachments {
+    create(sizeBytes: number, signal?: AbortSignal): Promise<{
+        attachment: ChatAttachment;
+        upload: ChatPresignedUrl;
+    }>;
+    commit(attachmentId: string, owner: {
+        kind: "message" | "summary";
+        id: string;
+    }, signal?: AbortSignal): Promise<ChatAttachment>;
+    get(attachmentId: string, signal?: AbortSignal): Promise<{
+        attachment: ChatAttachment;
+        download?: ChatPresignedUrl;
+    } | null>;
+    delete(attachmentId: string, signal?: AbortSignal): Promise<void>;
+}
+interface ChatListOptions {
+    kind: ChatRecordKind;
+    conversationId?: string;
+    includeDeleted?: boolean;
+    cursor?: string;
+    limit?: number;
+    signal?: AbortSignal;
+}
+interface ChatPage {
+    items: ChatSnapshot[];
+    nextCursor?: string;
+    total?: number;
+}
+/** Explicit versions protect edits; ambiguous writes are never replayed automatically. */
+interface ChatStore {
+    get(kind: ChatRecordKind, id: string, signal?: AbortSignal): Promise<ChatSnapshot | null>;
+    list(options: ChatListOptions): Promise<ChatPage>;
+    putMany(writes: readonly ChatWrite[], signal?: AbortSignal): Promise<ChatSnapshot[]>;
+    getMany(refs: readonly ChatRef[], signal?: AbortSignal): Promise<ChatSnapshot[]>;
+    account(signal?: AbortSignal): Promise<ChatAccount>;
+    importRecords(records: readonly ChatImport[], signal?: AbortSignal): Promise<number>;
+    verify(revisions: readonly ChatRevision[], signal?: AbortSignal): Promise<ChatRef[]>;
+    activate(signal?: AbortSignal): Promise<boolean>;
+    changes(cursor?: string, options?: {
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<ChatChanges>;
+    search(embedding: readonly number[], options?: ChatSearchOptions): Promise<ChatSearchHit[]>;
+    deleteAll(signal?: AbortSignal): Promise<number>;
+    attachments: ChatAttachments;
+}
+interface RemoteChatStoreOptions {
+    baseUrl: string;
+    getToken: () => Promise<string | null>;
+    keyId: string;
+    encrypt: (plaintext: string) => Promise<string>;
+    decrypt: (ciphertext: string) => Promise<string>;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+declare class ChatStoreError extends Error {
+    readonly status: number;
+    readonly code?: string | undefined;
+    readonly retryAfterMs?: number | undefined;
+    constructor(message: string, status: number, code?: string | undefined, retryAfterMs?: number | undefined);
+}
+
+interface ChatMigrationOptions {
+    /** The device's local chat database. */
+    database: Database;
+    /** Vault, opened with the account's canonical key. */
+    store: ChatStore;
+    walletAddress?: string;
+    signMessage?: SignMessageFn;
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+    /** Runs the final pass while local chat writers are held, so nothing lands locally after it. */
+    withWriteBarrier: (task: () => Promise<ChatMigrationResult>) => Promise<ChatMigrationResult>;
+    /** Called once vault holds everything; hand the device over to vault here. */
+    onActivated: () => void | Promise<void>;
+    /** Activate even when some rows could not be read; they stay on the device. */
+    allowSkipped?: boolean;
+    maxVectors?: number;
+    maxStorageBytes?: number;
+    signal?: AbortSignal;
+    onProgress?: (progress: ChatMigrationProgress) => void;
+}
+interface ChatMigrationProgress {
+    imported: number;
+    toImport: number;
+}
+interface ChatMigrationSkip {
+    kind: ChatRecordKind;
+    id: string;
+    reason: "unreadable" | "invalid";
+}
+interface ChatMigrationResult {
+    state: "migrating" | "active";
+    conversations: number;
+    messages: number;
+    imported: number;
+    skipped: ChatMigrationSkip[];
+    /** Conversations whose title could not be decrypted and went up untitled. */
+    untitled: number;
+    /** Messages sent without vectors to stay inside the account's vector quota. */
+    unembedded: number;
+    /** Messages shrunk to fit vault's record limit. */
+    truncated: number;
+}
+/** Copies this device's chats to vault, verifies them under the write barrier, then activates vault and hands the device over. */
+declare function migrateChatsToRemote(options: ChatMigrationOptions): Promise<ChatMigrationResult>;
+
+/** Connect to owner-scoped server storage using the account's canonical device-held cipher. */
+declare function createRemoteChatStore(options: RemoteChatStoreOptions): Promise<ChatStore>;
+
+declare class VaultMemory extends Model {
+    static table: string;
+    content: string;
+    scope: string;
+    /** Profile kind, or null for a free-form memory. */
+    kind: string | null;
+    /** Canonical JSON value of a kinded memory, encrypted at rest. */
+    kindValue: string | null;
+    /** private | matching | profile. */
+    level: string | null;
+    folderId: string | null;
+    userId: string | null;
+    embedding: string | null;
+    /** Model that produced `embedding`. Null on legacy rows (grandfathered). */
+    embeddingModel: string | null;
+    sourceChunkIds: string | null;
+    proofCount: number | null;
+    source: string | null;
+    /** W6 temporal lane — Unix ms timestamp of when the event occurred. */
+    eventTimeStart: number | null;
+    /** W6 temporal lane — Unix ms timestamp of event end (range/ongoing). */
+    eventTimeEnd: number | null;
+    /** W6 temporal lane — `point | range | ongoing | null`. */
+    eventTimeKind: string | null;
+    /** When true, the user has manually set this memory's topics; auto-extraction
+     *  leaves its entity links alone. Null on legacy rows (treated as false). */
+    topicsUserManaged: boolean | null;
+    /** The durable, synced record of this memory's topics — JSON `StoredTopic[]`.
+     *  `entity` / `memory_entity` are a device-local index over it. Null = pre-v42
+     *  (backfilled from the row's current links by the sweep). */
+    topics: string | null;
+    /** Unix ms of the last `topics` write. Separate from `updated_at`, which every
+     *  topic writer pins on purpose (recall recency) — see the schema note. */
+    topicsUpdatedAt: number | null;
+    /** The photo(s) a SERVER-EXTRACTED memory came from — JSON
+     *  `[{feed_item_id, object_key}]`, exactly the shape
+     *  GET /api/memories/published returns. Null on anything not from a photo. */
+    media: string | null;
+    /** Unix ms of the last LLM topic-extraction pass. Null = never extracted
+     *  standalone (linked legacy rows are grandfathered as extracted).
+     *  DEPRECATED (v42) — subsumed by `topics_updated_at`; see the schema note. */
+    topicsExtractedAt: number | null;
+    /** A2 supersession: newer memory id that replaced this one, or null if live. */
+    supersededBy: string | null;
+    supersededAt: number | null;
+    /** Extraction-logic version this memory was last stamped under. Null (pre-v38)
+     *  reads as 0, so a TOPICS_EXTRACTION_VERSION bump re-extracts stale rows.
+     *  DEPRECATED (v42) — subsumed by `topics_updated_at`; see the schema note. */
+    topicsExtractedVersion: number | null;
+    /** C3 re-observation watermark: Unix ms of the last retain() merge, or null. */
+    lastObservedAt: number | null;
+    /** Typed memory (PR1) — the extractor's FactType. Null on legacy/manual rows. */
+    factType: string | null;
+    /** Decay archive state (PR2) — Unix ms when archived, null when active. */
+    archivedAt: number | null;
+    /** Tier-0 security (PR3) — "quarantined" | "trusted" | null. */
+    trustTier: string | null;
+    /** People Nearby visibility: 'private' | 'public'. Null on legacy rows, and
+     *  any unrecognised value, read as 'private' — never published without opt-in. */
+    visibility: string | null;
+    /** Owner opted this memory into their own digital twin (twin-scoped only). */
+    twinOptIn: boolean | null;
+    /** Unix ms when visibility last became non-private; null while private. */
+    publishedAt: number | null;
+    /** Reserved coarse-geohash slot for landmark/Trail memories. */
+    geohash: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+}
+
+/**
+ * A canonical entity (person, place, thing) extracted from the user's
+ * conversations. Many-to-many with vault memories via {@link MemoryEntity}.
  *
- * For Privy embedded wallets, you can provide an `embeddedWalletSigner` function
- * to enable silent signing without user confirmation modals. This is useful for
- * deterministic key generation that should happen automatically.
+ * Created on the write path by the auto-extraction worker (W2) when a
+ * candidate fact arrives with non-empty `entities[]`. Used at retrieval
+ * time as a 3rd RRF lane (W5 graph traversal): query entity overlap
+ * with stored memories surfaces topically-related facts that pure
+ * semantic search misses.
+ */
+declare class Entity extends Model {
+    static table: string;
+    /** Lowercased, trimmed name used for dedup and lookup. */
+    canonicalName: string;
+    /** Optional category — "person" | "place" | "thing" | "concept" | etc. */
+    kind: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Join row: a memory references an entity (and vice versa). Multiple
+ * rows per memory (one per entity) and per entity (one per memory).
+ */
+declare class MemoryEntity extends Model {
+    static table: string;
+    memoryId: string;
+    entityId: string;
+    /**
+     * User-scope for the W5 graph lane. Optional because client-side
+     * (single-user) deployments may leave it null; server-side multi-user
+     * deployments must set it so retrieval can filter cross-user IDs.
+     */
+    userId: string | null;
+    createdAt: Date;
+}
+
+/**
+ * The recognized entity classifications. Runtime list + derived type kept
+ * in one place so the extractor's validation and the `EntityKind` union
+ * can't drift apart.
+ * @public
+ */
+declare const ENTITY_KINDS: readonly ["person", "organization", "place", "event", "product", "thing", "concept", "other"];
+/** @public */
+type EntityKind = (typeof ENTITY_KINDS)[number];
+interface StoredEntity {
+    uniqueId: string;
+    canonicalName: string;
+    kind: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+/**
+ * Who put a topic on a memory. Written to `memory_vault.topics` but not yet
+ * READ anywhere — it exists so a later improvement can refresh the `auto`
+ * entries of a curated memory while leaving `user` entries alone (today
+ * `topics_user_managed` is all-or-nothing per memory) without needing a second
+ * migration or backfill. Don't build that behavior off it yet.
  *
- * @param signMessage - Function to sign a message (from Privy's useSignMessage hook)
- * @param embeddedWalletSigner - Optional function for silent signing with embedded wallets
- * @returns Functions to request encryption keys and manage key pairs
+ * When you do: a value written by the v42 backfill is NOT ground truth. Pre-v42
+ * rows carry no per-topic provenance, so `backfillMemoryTopicsOp` derives it
+ * from the per-memory `topics_user_managed` flag and stamps a curated legacy
+ * row's every topic `user` — see the note at that derivation.
+ * @public
+ */
+type TopicSource = "user" | "auto";
+/**
+ * One entry in `memory_vault.topics` — the durable, synced record of a memory's
+ * topics. `name` carries the CALLER's display casing, unlike
+ * {@link StoredEntity.canonicalName}, which {@link normalizeEntityName}
+ * lowercases and which has no display column: preserving casing here is the
+ * point of storing names on the memory row.
+ * @public
+ */
+interface StoredTopic {
+    name: string;
+    kind?: string;
+    source: TopicSource;
+    /** How central the topic is to the memory, in (0, 1]; read it with {@link topicWeight}. */
+    weight?: number;
+}
+/**
+ * Fixed weight per salience level the topic extractor assigns.
+ * @public
+ */
+declare const TOPIC_SALIENCE_WEIGHTS: {
+    readonly primary: 1;
+    readonly secondary: 0.6;
+    readonly mention: 0.3;
+};
+/** @public */
+type TopicSalience = keyof typeof TOPIC_SALIENCE_WEIGHTS;
+/**
+ * A topic's weight: 1 when it is user-set or carries no weight.
+ * @public
+ */
+declare function topicWeight(topic: StoredTopic): number;
+/**
+ * The first topic with the highest weight, or null when there are none.
+ * @public
+ */
+declare function primaryTopic(topics: readonly StoredTopic[] | null | undefined): StoredTopic | null;
+/** @public */
+interface CreateEntityOptions {
+    canonicalName: string;
+    kind?: EntityKind | (string & {});
+}
+
+/**
+ * Accepted entity shape for {@link linkMemoryEntitiesOp}. A bare string is
+ * a name with no kind (back-compat with the original signature); the object
+ * form carries an optional classification.
+ * @public
+ */
+type EntityInput = string | {
+    name: string;
+    kind?: EntityKind | (string & {});
+    weight?: number;
+};
+interface EntityOperationsContext {
+    database: Database;
+    entityCollection: Collection<Entity>;
+    memoryEntityCollection: Collection<MemoryEntity>;
+    /**
+     * Optional user-scope. When provided, `linkMemoryEntitiesOp` stamps
+     * `user_id` on new memory_entity rows and `getMemoriesByEntityNamesOp`
+     * filters lookups by it. Leave undefined for single-user clients.
+     */
+    userId?: string;
+    /**
+     * When `true`, `getMemoriesByEntityNamesOp` admits rows with
+     * `user_id = null` alongside the strict `userId` match. Set this on
+     * LokiJS (web) adapters where the v31 `unsafeExecuteSql` backfill
+     * is a no-op — pre-v31 rows otherwise become invisible to the W5
+     * lane until `backfillMemoryEntityUserIdsOp` runs. Default `false`
+     * (server / SQLite, where the migration backfill is authoritative).
+     */
+    allowUnscopedRows?: boolean;
+    canWrite?: () => Promise<boolean>;
+}
+/**
+ * Link a memory to one or more entities. Accepts bare names (back-compat)
+ * or `{ name, kind }` objects. Names are normalized; missing entities are
+ * auto-created (with their kind), and an existing entity's null kind is
+ * back-filled — see {@link upsertEntitiesInWrite}. Idempotent — duplicate
+ * (memory_id, entity_id) pairs are skipped.
  *
- * @example
- * ```tsx
- * import { usePrivy, useWallets } from "@privy-io/react-auth";
- * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
+ * `options.unlessTopicsUserManaged` re-checks the memory's vault row INSIDE
+ * the serialized writer and skips link creation when the row is user-managed
+ * (`topics_user_managed`), soft-deleted, or absent. Auto paths (extraction,
+ * topic worker) need this: a pre-call check races the LLM round-trip —
+ * `setMemoryEntitiesOp` sets the flag in its own writer and a delete can land
+ * mid-call (orphaning links the cascade already swept) — so only an in-write
+ * check guarantees a user's manual edit or delete can't be grafted over. The
+ * row read fails CLOSED (skip links) so a transient fault never attaches
+ * topics to a memory we couldn't verify. Entity upserts and link creation
+ * run in ONE writer to prevent orphan-prune races; returns [] when links
+ * were skipped.
  *
- * function SecureComponent() {
- *   const { user, signMessage } = usePrivy();
- *   const { wallets } = useWallets();
- *   const embeddedWallet = wallets.find(w => w.walletClientType === 'privy');
+ * `options.topicsSource` (default `auto`) is the provenance recorded in
+ * `memory_vault.topics`, which this rewrites from the memory's FULL resulting
+ * link set — see {@link prepareTopicsUpdate}. Add semantics mean that set is
+ * old ∪ new, so already-linked entities are resolved for their names too.
  *
- *   // Create silent signer for embedded wallets
- *   const embeddedSigner = useCallback(async (message: string) => {
- *     if (embeddedWallet) {
- *       const { signature } = await embeddedWallet.signMessage({ message });
- *       return signature;
- *     }
- *     throw new Error('No embedded wallet');
- *   }, [embeddedWallet]);
+ * @deprecated App code: use `MemoryStore.addTopics` (`createLocalMemoryStore`).
+ */
+declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>, options?: {
+    unlessTopicsUserManaged?: boolean;
+    topicsSource?: TopicSource;
+}): Promise<StoredEntity[]>;
+/**
+ * REPLACE a memory's entity links with an auto-derived set — the topic
+ * worker's write primitive. Unlike {@link setMemoryEntitiesOp} it does NOT
+ * mark the memory user-managed (the pass is automatic), and unlike
+ * {@link linkMemoryEntitiesOp} it removes stale links, so re-extracting an
+ * edited memory drops entities its previous content mentioned ("works at
+ * Acme" → "works at Globex" must unlink Acme). Insert-missing and
+ * destroy-stale are batched in ONE writer, after the same in-write guard as
+ * the link op (user-managed / deleted / absent / read-fault ⇒ skip).
  *
- *   const { requestEncryptionKey } = useEncryption(signMessage, embeddedSigner);
+ * That batch also prunes `entity` rows left with no links at all (see
+ * {@link findOrphanedEntities}) — otherwise a topic the extractor has disowned
+ * keeps rendering as a chip that matches no memory.
  *
- *   // Request encryption key when user is authenticated
- *   useEffect(() => {
- *     if (user?.wallet?.address) {
- *       // This will use silent signing for embedded wallets
- *       await requestEncryptionKey(user.wallet.address);
- *     }
- *   }, [user]);
+ * Returns the linked entities ([] for an answered-empty set), or null when
+ * the guard skipped — callers must treat null as "not persisted" (e.g. don't
+ * stamp `topics_extracted_at`).
+ */
+declare function replaceMemoryEntitiesGuardedOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>): Promise<StoredEntity[] | null>;
+/**
+ * Backfill `memory_entity.user_id` from the parent vault row's user_id.
+ * Idempotent — only touches rows where user_id is null.
  *
- *   // Encrypt data
- *   const saveSecret = async (text: string) => {
- *     const encrypted = await encryptData(text, user.wallet.address);
- *     localStorage.setItem("mySecret", encrypted);
- *   };
+ * Why this exists: the v31 schema migration backfills via
+ * `unsafeExecuteSql`, which is a no-op on the LokiJS (web) adapter. Native
+ * SQLite installs have already been filled by the migration; web installs
+ * upgrading through v31 keep `user_id=null` on every pre-existing
+ * `memory_entity` row until this helper runs.
  *
- *   // Decrypt data
- *   const loadSecret = async () => {
- *     const encrypted = localStorage.getItem("mySecret");
- *     if (encrypted) {
- *       const decrypted = await decryptData(encrypted, user.wallet.address);
- *       console.log(decrypted);
- *     }
- *   };
+ * Consumers wiring an `EntityOperationsContext` with `userId` set are
+ * obliged to call this once on first use — `getMemoriesByEntityNamesOp`
+ * strictly filters by `user_id`, so unstamped rows are otherwise
+ * invisible to the W5 graph lane.
  *
- *   return (
- *     <div>
- *       <button onClick={() => saveSecret("my secret data")}>Encrypt & Save</button>
- *       <button onClick={loadSecret}>Load & Decrypt</button>
- *     </div>
- *   );
- * }
- * ```
+ * @public
+ */
+declare function backfillMemoryEntityUserIdsOp(ctx: EntityOperationsContext, vaultMemoryCollection: {
+    find: (id: string) => Promise<{
+        userId?: string | null;
+    }>;
+}): Promise<number>;
+/**
+ * W5 graph-lane read: given a set of entity names (e.g. extracted from
+ * a query), return the set of memory IDs linked to *any* of them, with
+ * a per-memory count of how many of the queried entities they match.
  *
- * @example
- * ```tsx
- * // Standard usage with external wallets (shows confirmation modal)
- * import { usePrivy } from "@privy-io/react-auth";
- * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
+ * Caller passes the result to `rankByEntityOverlap` to score each
+ * memory via `tanh(0.5 × shared_entity_count)` — this op only does the
+ * cheap "find candidate memories" step and leaves scoring to the
+ * ranker so callers can attach their own kind-weights or alternative
+ * scoring strategies later.
  *
- * function SecureComponent() {
- *   const { user, signMessage } = usePrivy();
- *   const { requestEncryptionKey } = useEncryption(signMessage);
+ * Names are normalized (lowercased, trimmed). Empty input returns an
+ * empty map. Names that don't exist as entities contribute nothing.
  *
- *   // Request encryption key when user is authenticated
- *   useEffect(() => {
- *     if (user?.wallet?.address) {
- *       // This will prompt user to sign if key doesn't exist
- *       await requestEncryptionKey(user.wallet.address);
- *     }
- *   }, [user]);
- * }
- * ```
+ * Multi-user safety: when `ctx.userId` is set, results are filtered to
+ * memory_entity rows whose `user_id` matches. Without this filter the
+ * lane returns IDs from every user who tagged a matching entity.
  *
- * @example
- * ```tsx
- * // ECDH key pair generation for end-to-end encryption
- * import { usePrivy } from "@privy-io/react-auth";
- * import { useEncryption } from "@anuma/sdk/react";
+ * @deprecated App code: use `MemoryStore.memoriesByTopics` (`createLocalMemoryStore`).
+ */
+declare function getMemoriesByEntityNamesOp(ctx: EntityOperationsContext, entityNames: readonly string[]): Promise<Map<string, Set<string>>>;
+/**
+ * Reverse of {@link getMemoriesByEntityNamesOp}: given a set of memory IDs
+ * (e.g. the current BFS frontier), return each memory's set of linked
+ * canonical entity names. This is the missing primitive for multi-hop graph
+ * traversal (PR4) — one step outward from a memory to its neighbor entities,
+ * which the traversal then expands to reach topically-adjacent memories.
  *
- * function E2EEComponent() {
- *   const { signMessage } = usePrivy();
- *   const { requestKeyPair, exportPublicKey } = useEncryption(signMessage);
+ * Empty input returns an empty map. Memory IDs with no links contribute
+ * nothing (they simply don't appear as keys).
  *
- *   const setupEncryption = async (walletAddress: string) => {
- *     // Generate deterministic ECDH key pair from wallet signature
- *     await requestKeyPair(walletAddress);
+ * Multi-user safety mirrors {@link getMemoriesByEntityNamesOp} exactly: when
+ * `ctx.userId` is set, only `memory_entity` rows owned by that user are
+ * followed (with the same `allowUnscopedRows` LokiJS escape hatch for pre-v31
+ * rows whose `user_id` backfill was a no-op). Without the filter the reverse
+ * lookup would leak entity links written by other users.
  *
- *     // Export public key to share with others
- *     const publicKey = await exportPublicKey(walletAddress);
- *     console.log("Share this public key:", publicKey);
- *   };
- * }
- * ```
+ * @public
  *
- * @category Hooks
+ * @deprecated App code: use `MemoryStore.topicsByMemories` (`createLocalMemoryStore`).
  */
-declare function useEncryption(signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): UseEncryptionResult;
+declare function getEntitiesByMemoryIdsOp(ctx: EntityOperationsContext, memoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
 
 /**
  * Checks if a string value is encrypted (has the enc:v2: or enc:v3: prefix with valid hex payload).
@@ -4650,292 +4608,121 @@ interface MemoryVaultSearchOptions {
     admitFloor?: number;
 }
 /**
- * Pre-embed all vault memories that are not yet in the cache.
- * Call this at init time so searches are instant.
- */
-declare function preEmbedVaultMemories(vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, options?: {
-    scopes?: string[];
-}): Promise<void>;
-/**
- * Eagerly embed a single piece of content and store it in the cache.
- * Call this when a vault memory is created or updated.
- */
-declare function eagerEmbedContent(content: string, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, vaultCtx?: VaultMemoryOperationsContext, memoryId?: string, 
-/**
- * `updatedAt` of the committed row this content belongs to. When given, the
- * cache entry is tied to that row version; without it the entry is
- * unversioned and a search re-resolves it from the stored column instead of
- * trusting it (see `vectorVersion.ts`).
- */
-updatedAt?: Date): Promise<void>;
-interface CorpusStats {
-    keysMs: number;
-    embeddingsFetchMs: number;
-    rowsFetchMs: number;
-    cacheHits: number;
-    cacheMisses: number;
-}
-/**
- * A single vault search result with its similarity score.
- */
-interface VaultSearchResult {
-    uniqueId: string;
-    content: string;
-    similarity: number;
-    /** Optional — surfaced by the rankers so downstream `RankedMemory` carries
-     * real timestamps. Omitted when an item lacks the field upstream. */
-    createdAt?: Date;
-    updatedAt?: Date;
-    /** Times this fact has been re-observed — for C2 trend labels. */
-    proofCount?: number | null;
-    /** C3 re-observation watermark (Unix ms) — for C2 trends + C4 CE dates. */
-    lastObservedAt?: number | null;
-    /** W6 temporal-lane anchors carried through to downstream `RankedMemory`
-     * so the recall executor can surface dates to the answer model without
-     * a second per-fact DB lookup + decrypt. Unix ms; null when the fact
-     * has no anchored event time. */
-    eventTimeStart?: number | null;
-    eventTimeEnd?: number | null;
-    eventTimeKind?: "point" | "range" | "ongoing" | null;
-    /** Typed memory (PR1) — the fact's FactType, threaded through from the
-     * storage row alongside the event-time anchors. Null/undefined when
-     * untyped. Loose string (originates from a stored column). */
-    factType?: string | null;
-    /** Message ids this fact was extracted from (provenance). recall() uses
-     * these to suppress the originating chunk in the chunk lane. */
-    sourceChunkIds?: string[] | null;
-}
-/**
- * Search + rank in one call. Thin wrapper over {@link prepareVaultCandidates} +
- * {@link rankPreparedVaultCandidates}; behavior is unchanged.
- */
-declare function searchVaultMemoriesWithSize(query: string, vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, searchOptions?: MemoryVaultSearchOptions): Promise<{
-    results: VaultSearchResult[];
-    vaultSize: number;
-    reranked: boolean;
-    /**
-     * Wall-clock ms this search spent inside the cross-encoder.
-     *
-     * 0 on every path that did not reach the CE, which `reranked` already
-     * distinguishes from "ran and cost nothing". Reported because `factLane`
-     * timing alone could not separate the rerank from the query embed, the vault
-     * read and the fused ranking — see {@link RerankStats}.
-     */
-    rerankMs: number;
-    hadV2Head: boolean;
-    /** True when this search had no usable cosine lane and ranked on BM25 alone. */
-    embeddingsUnavailable: boolean;
-    /**
-     * True when this search actually scored rows against a real query vector.
-     *
-     * NOT the inverse of `embeddingsUnavailable`. That flag answers "did cosine
-     * break?", and it is `false` on the degenerate returns below — an invalid
-     * query, an empty scope, nothing decryptable — where cosine did not break so
-     * much as never run. A caller asking "can this lane vouch that semantic
-     * ranking happened?" (recall's chunk-lane reconciliation) must not read those
-     * as a healthy cosine pass.
-     */
-    rankedOnCosine: boolean;
-    /**
-     * Which vault read path ran — projected key scan (`true`) or legacy whole-vault
-     * load (`false`). See {@link PreparedVaultCandidates.decryptLast}.
-     */
-    decryptLast: boolean;
-    /**
-     * Rows this search paid to decrypt. Read against `vaultSize` — see
-     * {@link PreparedVaultCandidates.rowsDecrypted}.
-     */
-    rowsDecrypted: number;
-    /**
-     * Wall-clock ms spent embedding the query, and rows the lane had to re-embed
-     * because their stored vector was unusable — see
-     * {@link PreparedVaultCandidates.queryEmbedMs} and `rowsEmbedded`.
-     */
-    queryEmbedMs: number;
-    rowsEmbedded: number;
-    corpusStats?: CorpusStats;
-}>;
-/**
- * Search vault memories by semantic similarity. Returns structured results
- * sorted by descending similarity, filtered by threshold and limit.
- *
- * This is the standalone search logic extracted from `createMemoryVaultSearchTool`
- * so it can be called programmatically (e.g., for pre-retrieval injection).
- *
- * @returns Sorted results (empty array on invalid input or empty vault)
- */
-declare function searchVaultMemories(query: string, vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, searchOptions?: MemoryVaultSearchOptions): Promise<VaultSearchResult[]>;
-
-interface StorageOperationsContext {
-    database: Database;
-    messagesCollection: Collection<Message>;
-    conversationsCollection: Collection<Conversation>;
-    /** Wallet address for encryption (optional - when present, enables field-level encryption) */
-    walletAddress?: string;
-    /** Function to sign a message for encryption key derivation */
-    signMessage?: SignMessageFn;
-    /** Function for silent signing with embedded wallets */
-    embeddedWalletSigner?: EmbeddedWalletSignerFn;
-}
-/**
- * Lazy variant of {@link getConversationsOp}.
- *
- * Returns conversations with their raw stored title under
- * `encryptedTitle` instead of a decrypted `title`. Callers should pair
- * this with {@link decryptConversationTitle} (or the underlying
- * `decryptField`) and decrypt only when a row is rendered.
- *
- * Behavior is identical to `getConversationsOp` except for the title
- * projection — sort order, soft-delete filtering, and active-conversation
- * scoping all match.
- *
- * Encryption context on `ctx` is intentionally ignored: this op never
- * decrypts. That is also why the test for this op asserts call count
- * for `decryptField` is exactly zero.
- */
-declare function getConversationsLazyOp(ctx: StorageOperationsContext): Promise<LazyStoredConversation[]>;
-/**
- * Keyset-paginated, lazy (no-decrypt) variant of {@link getConversationsLazyOp}.
- *
- * Returns at most `limit` conversations (newest first by `created_at`), each
- * with its raw stored title under `encryptedTitle` — pair with
- * {@link decryptConversationTitle} to decrypt on render. Page through older
- * threads by passing the oldest loaded `createdAt` as `before` plus the
- * uniqueIds held at that boundary as `boundaryExcludeUniqueIds`.
- *
- * Decrypts nothing and builds no WatermelonDB Model (the never-evicted
- * RecordCache stays empty — web Pile-2). Sort order, soft-delete filtering,
- * and the encrypted-title projection all match `getConversationsLazyOp`.
- */
-declare function getConversationsPageOp(ctx: StorageOperationsContext, options?: GetConversationsPageOptions): Promise<LazyStoredConversation[]>;
-/**
- * Lazy variant of {@link getConversationsByProjectOp}.
- *
- * Same encrypted-title projection as {@link getConversationsLazyOp},
- * filtered by project assignment. Pass `null` to retrieve conversations
- * with no project.
- */
-declare function getConversationsByProjectLazyOp(ctx: StorageOperationsContext, projectId: string | null): Promise<LazyStoredConversation[]>;
-/**
- * Update a conversation's project assignment.
- * Pass null to remove the conversation from any project.
- */
-declare function updateConversationProjectOp(ctx: StorageOperationsContext, id: string, projectId: string | null): Promise<boolean>;
-/**
- * Get conversations filtered by project ID.
- * Pass null to get conversations that don't belong to any project.
- */
-declare function getConversationsByProjectOp(ctx: StorageOperationsContext, projectId: string | null): Promise<StoredConversation[]>;
-/**
- * Delete a single message by its unique ID.
- * Clears file_ids before deletion and returns the unique ID.
- * Note: Callers should use deleteMediaByMessageOp to cascade delete media.
- */
-declare function deleteMessageOp(ctx: StorageOperationsContext, uniqueId: string): Promise<string | null>;
-/** Decrypts raw message embedding columns with the cached wallet key. */
-declare function decryptMessageEmbeddingFields(raw: Record<string, unknown>, walletAddress?: string): Promise<Record<string, unknown>>;
-/** Seals legacy message embedding columns and discards chunks with invalid plaintext offsets. */
-declare function sealLegacyMessageEmbeddingsOp(ctx: StorageOperationsContext): Promise<number>;
-/**
- * Removes the plaintext `text` that rows chunked before sdk#889 still carry in
- * their `chunks` column. Since #889 `updateMessageChunksOp` never writes it, so
- * a stored `text` key identifies exactly the rows written before that change.
- * Readers rebuild the snippet from the offsets every row already has; a row
- * edited after it was chunked fails `resolveChunkText`'s coverage check and
- * shows the whole message instead.
- *
- * Every device must call it: each strips only its own local copy. Backups hold
- * whole rows encrypted, and a restore brings the text back until the next call.
- * Idempotent: a stripped row no longer matches, so calling it once per session
- * is safe. `updated_at` is kept as it was, so backup sync does not re-upload
- * every old row (the chunk vectors are most of each row's size).
- *
- * Reads raw rows a page at a time and builds Models only for the rows it
- * changes, so unchanged candidates never enter the record cache, and each
- * write stays small enough not to hold up chat saves.
- *
- * @returns Number of rows stripped.
- */
-declare function stripLegacyChunkTextOp(ctx: StorageOperationsContext): Promise<number>;
-/**
- * Encrypts tool call arguments and results still stored in plaintext and
- * returns how many rows changed, giving each touched conversation a new
- * `updatedAt` so backups re-upload it, which moves it to the top of any list
- * sorted by `updatedAt`.
- */
-declare function encryptToolCallEventsOp(ctx: StorageOperationsContext): Promise<number>;
-/**
- * Update the feedback (like/dislike) for a message.
- * Each regenerated response can have its own independent feedback.
- *
- * @param ctx - Storage operations context
- * @param uniqueId - The unique ID of the message to update
- * @param feedback - 'like', 'dislike', or null to clear feedback
- * @returns The updated message or null if not found
- */
-declare function updateMessageFeedbackOp(ctx: StorageOperationsContext, uniqueId: string, feedback: MessageFeedback): Promise<StoredMessage | null>;
-declare function searchMessagesOp(ctx: StorageOperationsContext, queryVector: number[], options?: {
-    limit?: number;
-    minSimilarity?: number;
-    conversationId?: string;
-}): Promise<StoredMessageWithSimilarity[]>;
-/**
- * Decrypted, model-native chunk vectors for one message, cached across recall
- * calls so the chunk lane doesn't re-decrypt + re-JSON.parse every message's
- * embeddings on every query. Keyed by message id; `version` is the message's
- * `updated_at` at cache time, so a re-embed (which bumps `updated_at`) misses
- * and repopulates. Vectors are stored Float32 — model-native precision, half
- * the RAM of float64 `number[]` — mirroring the vault embedding cache (#705).
- * Content text is deliberately NOT cached (see searchChunksOp): it isn't
- * needed for scoring, and keeping decrypted content out of the cache preserves
- * the SDK's data-at-rest posture.
- */
-interface CachedChunkVectors {
-    /** Message `updated_at` (ms) at cache time — the invalidation token. */
-    version: number;
-    /**
-     * Per-chunk embedding vectors, index-aligned with the message's decrypted
-     * `chunks` array (empty-vector chunks kept as zero-length placeholders so
-     * indices stay aligned). Empty when the message has only a whole-message
-     * `fallback` vector.
-     */
-    chunks: Float32Array[];
-    /** Whole-message vector when the message was embedded without chunking. */
-    fallback?: Float32Array;
-}
-/**
- * Cache consumed by {@link searchChunksOp}, keyed by message id. A plain `Map`
- * (satisfied by the LRU from `createChunkVectorCache`) — mirrors
- * `VaultEmbeddingCache` so consumers get the same `clear()`/`delete()`
- * ergonomics on an encryption-key reset.
+ * Pre-embed all vault memories that are not yet in the cache.
+ * Call this at init time so searches are instant.
  */
-type ChunkVectorCache = Map<string, CachedChunkVectors>;
-/** Row counts from one {@link searchChunksOp} call. */
-interface ChunkSearchStats {
-    /** Embedded messages in live conversations that the search considered. */
-    rowsScanned: number;
-    /** Messages whose vectors were read from storage because the cache missed. */
-    rowsFetched: number;
-    /** Messages scored straight from the vector cache. */
+declare function preEmbedVaultMemories(vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, options?: {
+    scopes?: string[];
+}): Promise<void>;
+/**
+ * Eagerly embed a single piece of content and store it in the cache.
+ * Call this when a vault memory is created or updated.
+ */
+declare function eagerEmbedContent(content: string, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, vaultCtx?: VaultMemoryOperationsContext, memoryId?: string, 
+/**
+ * `updatedAt` of the committed row this content belongs to. When given, the
+ * cache entry is tied to that row version; without it the entry is
+ * unversioned and a search re-resolves it from the stored column instead of
+ * trusting it (see `vectorVersion.ts`).
+ */
+updatedAt?: Date): Promise<void>;
+interface CorpusStats {
+    keysMs: number;
+    embeddingsFetchMs: number;
+    rowsFetchMs: number;
     cacheHits: number;
+    cacheMisses: number;
 }
 /**
- * Search through message chunks for fine-grained semantic search.
- * Returns the matching chunk text along with the parent message.
+ * A single vault search result with its similarity score.
  */
-declare function searchChunksOp(ctx: StorageOperationsContext, queryVector: number[], options?: {
-    limit?: number;
-    minSimilarity?: number;
-    conversationId?: string;
-    /** Skip every message in this conversation before scoring. */
-    excludeConversationId?: string;
-    /** Current embedding model; messages stored under a different non-null model are skipped. */
-    embeddingModel?: string;
-    /** Decrypted-vector cache, validated by `updated_at`. */
-    chunkCache?: ChunkVectorCache;
-    /** Receives row counts for the call. */
-    onStats?: (stats: ChunkSearchStats) => void;
-}): Promise<ChunkSearchResult[]>;
+interface VaultSearchResult {
+    uniqueId: string;
+    content: string;
+    similarity: number;
+    /** Optional — surfaced by the rankers so downstream `RankedMemory` carries
+     * real timestamps. Omitted when an item lacks the field upstream. */
+    createdAt?: Date;
+    updatedAt?: Date;
+    /** Times this fact has been re-observed — for C2 trend labels. */
+    proofCount?: number | null;
+    /** C3 re-observation watermark (Unix ms) — for C2 trends + C4 CE dates. */
+    lastObservedAt?: number | null;
+    /** W6 temporal-lane anchors carried through to downstream `RankedMemory`
+     * so the recall executor can surface dates to the answer model without
+     * a second per-fact DB lookup + decrypt. Unix ms; null when the fact
+     * has no anchored event time. */
+    eventTimeStart?: number | null;
+    eventTimeEnd?: number | null;
+    eventTimeKind?: "point" | "range" | "ongoing" | null;
+    /** Typed memory (PR1) — the fact's FactType, threaded through from the
+     * storage row alongside the event-time anchors. Null/undefined when
+     * untyped. Loose string (originates from a stored column). */
+    factType?: string | null;
+    /** Message ids this fact was extracted from (provenance). recall() uses
+     * these to suppress the originating chunk in the chunk lane. */
+    sourceChunkIds?: string[] | null;
+}
+/**
+ * Search + rank in one call. Thin wrapper over {@link prepareVaultCandidates} +
+ * {@link rankPreparedVaultCandidates}; behavior is unchanged.
+ */
+declare function searchVaultMemoriesWithSize(query: string, vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, searchOptions?: MemoryVaultSearchOptions): Promise<{
+    results: VaultSearchResult[];
+    vaultSize: number;
+    reranked: boolean;
+    /**
+     * Wall-clock ms this search spent inside the cross-encoder.
+     *
+     * 0 on every path that did not reach the CE, which `reranked` already
+     * distinguishes from "ran and cost nothing". Reported because `factLane`
+     * timing alone could not separate the rerank from the query embed, the vault
+     * read and the fused ranking — see {@link RerankStats}.
+     */
+    rerankMs: number;
+    hadV2Head: boolean;
+    /** True when this search had no usable cosine lane and ranked on BM25 alone. */
+    embeddingsUnavailable: boolean;
+    /**
+     * True when this search actually scored rows against a real query vector.
+     *
+     * NOT the inverse of `embeddingsUnavailable`. That flag answers "did cosine
+     * break?", and it is `false` on the degenerate returns below — an invalid
+     * query, an empty scope, nothing decryptable — where cosine did not break so
+     * much as never run. A caller asking "can this lane vouch that semantic
+     * ranking happened?" (recall's chunk-lane reconciliation) must not read those
+     * as a healthy cosine pass.
+     */
+    rankedOnCosine: boolean;
+    /**
+     * Which vault read path ran — projected key scan (`true`) or legacy whole-vault
+     * load (`false`). See {@link PreparedVaultCandidates.decryptLast}.
+     */
+    decryptLast: boolean;
+    /**
+     * Rows this search paid to decrypt. Read against `vaultSize` — see
+     * {@link PreparedVaultCandidates.rowsDecrypted}.
+     */
+    rowsDecrypted: number;
+    /**
+     * Wall-clock ms spent embedding the query, and rows the lane had to re-embed
+     * because their stored vector was unusable — see
+     * {@link PreparedVaultCandidates.queryEmbedMs} and `rowsEmbedded`.
+     */
+    queryEmbedMs: number;
+    rowsEmbedded: number;
+    corpusStats?: CorpusStats;
+}>;
+/**
+ * Search vault memories by semantic similarity. Returns structured results
+ * sorted by descending similarity, filtered by threshold and limit.
+ *
+ * This is the standalone search logic extracted from `createMemoryVaultSearchTool`
+ * so it can be called programmatically (e.g., for pre-retrieval injection).
+ *
+ * @returns Sorted results (empty array on invalid input or empty vault)
+ */
+declare function searchVaultMemories(query: string, vaultCtx: VaultMemoryOperationsContext, embeddingOptions: EmbeddingOptions, cache: VaultEmbeddingCache, searchOptions?: MemoryVaultSearchOptions): Promise<VaultSearchResult[]>;
 
 /** Recent window — observations inside this count as "active". */
 declare const TREND_RECENT_WINDOW_DAYS = 30;
@@ -5204,8 +4991,10 @@ interface RecallContext {
     factSource?: RecallFactSource;
     /** Required when `types` includes 'fact'. */
     vaultCtx?: VaultMemoryOperationsContext;
-    /** Required when `types` includes 'chunk'. */
+    /** Required when `types` includes 'chunk', unless `chats` is given. */
     storageCtx?: StorageOperationsContext;
+    /** Chat chunk search; takes precedence over `storageCtx`. */
+    chats?: Pick<ChatBackend, "searchChunks">;
     /** Embedding API options. */
     embeddingOptions: EmbeddingOptions;
     /** Vault embedding LRU cache. */
@@ -8510,6 +8299,27 @@ interface LazyStoredConversation extends Omit<StoredConversation, "title"> {
 interface StoredMessageWithSimilarity extends StoredMessage {
     similarity: number;
 }
+/**
+ * Cached conversation summary for progressive history summarization.
+ *
+ * Instead of sending all conversation history verbatim on every message,
+ * older messages are progressively summarized into a compact text.
+ * This reduces input tokens by 50-70% for long conversations.
+ */
+interface StoredConversationSummary {
+    /** WatermelonDB record ID */
+    uniqueId: string;
+    /** Conversation this summary belongs to */
+    conversationId: string;
+    /** The progressive summary text */
+    summary: string;
+    /** uniqueId of the last message included in the summary */
+    summarizedUpTo: string;
+    /** Approximate token count of the summary (chars / 4) */
+    tokenCount: number;
+    createdAt: Date;
+    updatedAt: Date;
+}
 /**
  * A chunk of a message with its own embedding for fine-grained search
  */
@@ -8629,6 +8439,8 @@ interface BaseUseChatStorageOptions {
     database: Database;
     /** Route memory operations through this store; `null` disables memory access while `undefined` uses the local vault. Folders are unsupported. With `piiRedaction` on, build the store with `embeddingOptions.maskInput` or its memory calls throw. */
     memoryStore?: MemoryStore | null;
+    /** Builds the chat storage backend (default: this `database`); keep it stable across renders, since a new factory rebuilds the backend and every callback. */
+    chatBackend?: ChatBackendFactory;
     /** ID of an existing conversation to load and continue */
     conversationId?: string;
     /** Automatically create a new conversation if none is set (default: true) */
@@ -9004,206 +8816,721 @@ interface BaseSendMessageWithStorageArgs {
      * Additional context from memory/RAG system to include in the request.
      * Typically contains retrieved relevant information from past conversations.
      */
-    memoryContext?: string;
+    memoryContext?: string;
+    /**
+     * Additional context from search results to include in the request.
+     * Typically contains relevant information from web or document searches.
+     */
+    searchContext?: string;
+    /**
+     * Additional context from preprocessed file attachments.
+     * Contains extracted text from Excel, Word, PDF, and other document files.
+     * Injected as a system message so it's available throughout the conversation.
+     */
+    fileContext?: string;
+    /**
+     * Search sources to attach to the stored message for citation/reference.
+     * Note: Sources are also automatically extracted from tool_call_events in the response.
+     */
+    sources?: SearchSource[];
+    /**
+     * Activity phases for tracking the request lifecycle in the UI.
+     * Each phase represents a step like "Searching", "Thinking", "Generating".
+     * The final phase is automatically marked as completed when stored.
+     *
+     * Note: If you need activity phases that are added during streaming (e.g., server tool calls),
+     * use `getThoughtProcess` callback instead, which captures phases AFTER streaming completes.
+     */
+    thoughtProcess?: ActivityPhase[];
+    /**
+     * Callback to get activity phases AFTER streaming completes.
+     * Use this instead of `thoughtProcess` when phases are added dynamically during streaming
+     * (e.g., via server tool call events like "Searching...", "Generating image...").
+     *
+     * If both `thoughtProcess` and `getThoughtProcess` are provided, `getThoughtProcess` takes precedence.
+     */
+    getThoughtProcess?: () => ActivityPhase[];
+    /**
+     * Controls randomness in the response (0.0 to 2.0).
+     * Lower values make output more deterministic, higher values more creative.
+     */
+    temperature?: number;
+    /**
+     * Maximum number of tokens to generate in the response.
+     * Use this to limit response length and control costs.
+     */
+    maxOutputTokens?: number;
+    /**
+     * Client-side tools with optional executors.
+     * These tools run in the browser/app and can have JavaScript executor functions.
+     */
+    clientTools?: LlmapiChatCompletionTool[];
+    /**
+     * Server-side tools to include from /api/v1/tools.
+     * - undefined: Include all server-side tools (default)
+     * - string[]: Include only tools with these names
+     * - []: Include no server-side tools
+     * - function: Dynamic filter that receives prompt embedding(s) and all tools,
+     *   returns tool names to include. Useful for semantic tool matching.
+     *
+     * @example
+     * // Include only specific server tools
+     * serverTools: ["anuma_create_image", "perplexity_search"]
+     *
+     * // Disable server tools for this request
+     * serverTools: []
+     *
+     * // Semantic tool matching based on prompt
+     * serverTools: (embeddings, tools) => {
+     *   const matches = findMatchingTools(embeddings, tools, { limit: 5 });
+     *   return matches.map(m => m.tool.name);
+     * }
+     */
+    serverTools?: ServerToolsFilter;
+    /**
+     * Dynamic filter for client-side tools based on prompt embeddings.
+     * Receives the prompt embedding(s) (or null for short messages) and all client tools,
+     * returns tool names to include. Tools not in the returned list are excluded from the request.
+     *
+     * @example
+     * clientToolsFilter: (embeddings, tools) => {
+     *   if (!embeddings) return []; // Short message — no client tools
+     *   const matches = findMatchingTools(embeddings, pseudoServerTools);
+     *   return matches.map(m => m.tool.name);
+     * }
+     */
+    clientToolsFilter?: ClientToolsFilterFn;
+    /**
+     * Controls which tool the model should use:
+     * - "auto": Model decides whether to use a tool (default)
+     * - "any": Model must use one of the provided tools
+     * - "none": Model cannot use any tools
+     * - "required": Model must use a tool
+     * - Specific tool name: Model must use that specific tool
+     */
+    toolChoice?: string;
+    /**
+     * Maximum number of tool execution rounds before forcing the model to respond with text.
+     * After this many rounds, `toolChoice` is set to `"none"` on the next continuation,
+     * so the model produces a text answer using whatever tool results it has gathered.
+     * @default 3
+     */
+    maxToolRounds?: number;
+    /**
+     * Reasoning configuration for o-series and other reasoning models.
+     * Controls reasoning effort level and whether to include reasoning summary.
+     */
+    reasoning?: LlmapiResponseReasoning;
+    /**
+     * Extended thinking configuration for Anthropic models (Claude).
+     * Enables the model to think through complex problems step by step
+     * before generating the final response.
+     */
+    thinking?: LlmapiThinkingOptions;
+    /** User-selected image generation model for server-side enforcement. */
+    imageModel?: string;
     /**
-     * Additional context from search results to include in the request.
-     * Typically contains relevant information from web or document searches.
+     * Per-request callback for thinking/reasoning chunks.
+     * Called with delta chunks as the model "thinks" through a problem.
+     * Use this to display thinking progress in the UI.
      */
-    searchContext?: string;
+    onThinking?: (chunk: string) => void;
+    /** Parent message ID for branching (edit/regenerate). Sets on the user message. */
+    parentMessageId?: string;
     /**
-     * Additional context from preprocessed file attachments.
-     * Contains extracted text from Excel, Word, PDF, and other document files.
-     * Injected as a system message so it's available throughout the conversation.
+     * Pre-generated unique ID for the assistant response message.
+     * When provided, the persisted assistant message will use this ID instead of
+     * an auto-generated one. This lets the consumer show an in-flight streaming
+     * placeholder under the same React key, avoiding an unmount/remount flash
+     * when streaming completes and the message is loaded from the database.
      */
-    fileContext?: string;
+    assistantUniqueId?: string;
+}
+interface BaseUseChatStorageResult {
+    isLoading: boolean;
+    stop: () => void;
+    conversationId: string | null;
+    setConversationId: (id: string | null) => void;
+    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
+    getConversation: (id: string) => Promise<StoredConversation | null>;
+    getConversations: () => Promise<StoredConversation[]>;
+    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
+    updateConversationPinned: (id: string, pinned: boolean) => Promise<boolean>;
+    deleteConversation: (id: string) => Promise<boolean>;
+    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
     /**
-     * Search sources to attach to the stored message for citation/reference.
-     * Note: Sources are also automatically extracted from tool_call_events in the response.
+     * Paginated display read: the newest `limit` messages (optionally below
+     * `beforeMessageId`), ascending, with embedding columns skipped.
      */
+    getMessagesPage: (conversationId: string, options: GetMessagesPageOptions) => Promise<StoredMessage[]>;
+    /** Whole-thread branch-tree skeleton — no field decryption. */
+    getMessageSkeletons: (conversationId: string) => Promise<MessageSkeleton[]>;
+    /** Total message count for a conversation. */
+    getMessageCount: (conversationId: string) => Promise<number>;
+}
+declare function generateConversationId(): string;
+
+declare class Message extends Model {
+    static table: string;
+    static associations: Associations;
+    messageId: number;
+    conversationId: string;
+    role: ChatRole;
+    content: string;
+    model?: string;
+    imageModel?: string;
+    /** @deprecated Use fileIds with media table instead */
+    files?: FileMetadata[];
+    /** Array of media_id references for direct lookup */
+    fileIds?: string[];
+    createdAt: Date;
+    updatedAt: Date;
+    vector?: number[];
+    embeddingModel?: string;
+    chunks?: MessageChunk[];
+    usage?: ChatCompletionUsage;
     sources?: SearchSource[];
+    responseDuration?: number;
+    wasStopped?: boolean;
+    error?: string;
+    thoughtProcess?: ActivityPhase[];
+    thinking?: string;
+    parentMessageId?: string;
+    feedback?: MessageFeedback;
+    toolCallEvents?: LlmapiToolCallEvent[];
+    /** Plaintext by design — see MessageOrigin */
+    origin?: MessageOrigin;
+}
+declare class Conversation extends Model {
+    static table: string;
+    static associations: Associations;
+    conversationId: string;
+    title: string;
+    projectId?: string;
+    createdAt: Date;
+    updatedAt: Date;
+    isDeleted: boolean;
+    /** When the conversation was pinned to the top of the list; null/unset = not pinned.
+     * `null` (not `undefined`) at runtime for unpinned rows — `@date` maps a null raw
+     * column to null, and unpin stores an explicit null. */
+    pinnedAt?: Date | null;
+}
+
+interface StorageOperationsContext {
+    database: Database;
+    messagesCollection: Collection<Message>;
+    conversationsCollection: Collection<Conversation>;
+    /** Wallet address for encryption (optional - when present, enables field-level encryption) */
+    walletAddress?: string;
+    /** Function to sign a message for encryption key derivation */
+    signMessage?: SignMessageFn;
+    /** Function for silent signing with embedded wallets */
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+}
+/**
+ * Lazy variant of {@link getConversationsOp}.
+ *
+ * Returns conversations with their raw stored title under
+ * `encryptedTitle` instead of a decrypted `title`. Callers should pair
+ * this with {@link decryptConversationTitle} (or the underlying
+ * `decryptField`) and decrypt only when a row is rendered.
+ *
+ * Behavior is identical to `getConversationsOp` except for the title
+ * projection — sort order, soft-delete filtering, and active-conversation
+ * scoping all match.
+ *
+ * Encryption context on `ctx` is intentionally ignored: this op never
+ * decrypts. That is also why the test for this op asserts call count
+ * for `decryptField` is exactly zero.
+ */
+declare function getConversationsLazyOp(ctx: StorageOperationsContext): Promise<LazyStoredConversation[]>;
+/**
+ * Keyset-paginated, lazy (no-decrypt) variant of {@link getConversationsLazyOp}.
+ *
+ * Returns at most `limit` conversations (newest first by `created_at`), each
+ * with its raw stored title under `encryptedTitle` — pair with
+ * {@link decryptConversationTitle} to decrypt on render. Page through older
+ * threads by passing the oldest loaded `createdAt` as `before` plus the
+ * uniqueIds held at that boundary as `boundaryExcludeUniqueIds`.
+ *
+ * Decrypts nothing and builds no WatermelonDB Model (the never-evicted
+ * RecordCache stays empty — web Pile-2). Sort order, soft-delete filtering,
+ * and the encrypted-title projection all match `getConversationsLazyOp`.
+ */
+declare function getConversationsPageOp(ctx: StorageOperationsContext, options?: GetConversationsPageOptions): Promise<LazyStoredConversation[]>;
+/**
+ * Lazy variant of {@link getConversationsByProjectOp}.
+ *
+ * Same encrypted-title projection as {@link getConversationsLazyOp},
+ * filtered by project assignment. Pass `null` to retrieve conversations
+ * with no project.
+ */
+declare function getConversationsByProjectLazyOp(ctx: StorageOperationsContext, projectId: string | null): Promise<LazyStoredConversation[]>;
+/**
+ * Update a conversation's project assignment.
+ * Pass null to remove the conversation from any project.
+ */
+declare function updateConversationProjectOp(ctx: StorageOperationsContext, id: string, projectId: string | null): Promise<boolean>;
+/**
+ * Get conversations filtered by project ID.
+ * Pass null to get conversations that don't belong to any project.
+ */
+declare function getConversationsByProjectOp(ctx: StorageOperationsContext, projectId: string | null): Promise<StoredConversation[]>;
+/**
+ * Delete a single message by its unique ID.
+ * Clears file_ids before deletion and returns the unique ID.
+ * Note: Callers should use deleteMediaByMessageOp to cascade delete media.
+ */
+declare function deleteMessageOp(ctx: StorageOperationsContext, uniqueId: string): Promise<string | null>;
+/** Decrypts raw message embedding columns with the cached wallet key. */
+declare function decryptMessageEmbeddingFields(raw: Record<string, unknown>, walletAddress?: string): Promise<Record<string, unknown>>;
+/** Seals legacy message embedding columns and discards chunks with invalid plaintext offsets. */
+declare function sealLegacyMessageEmbeddingsOp(ctx: StorageOperationsContext): Promise<number>;
+/**
+ * Removes the plaintext `text` that rows chunked before sdk#889 still carry in
+ * their `chunks` column. Since #889 `updateMessageChunksOp` never writes it, so
+ * a stored `text` key identifies exactly the rows written before that change.
+ * Readers rebuild the snippet from the offsets every row already has; a row
+ * edited after it was chunked fails `resolveChunkText`'s coverage check and
+ * shows the whole message instead.
+ *
+ * Every device must call it: each strips only its own local copy. Backups hold
+ * whole rows encrypted, and a restore brings the text back until the next call.
+ * Idempotent: a stripped row no longer matches, so calling it once per session
+ * is safe. `updated_at` is kept as it was, so backup sync does not re-upload
+ * every old row (the chunk vectors are most of each row's size).
+ *
+ * Reads raw rows a page at a time and builds Models only for the rows it
+ * changes, so unchanged candidates never enter the record cache, and each
+ * write stays small enough not to hold up chat saves.
+ *
+ * @returns Number of rows stripped.
+ */
+declare function stripLegacyChunkTextOp(ctx: StorageOperationsContext): Promise<number>;
+/**
+ * Encrypts tool call arguments and results still stored in plaintext and
+ * returns how many rows changed, giving each touched conversation a new
+ * `updatedAt` so backups re-upload it, which moves it to the top of any list
+ * sorted by `updatedAt`.
+ */
+declare function encryptToolCallEventsOp(ctx: StorageOperationsContext): Promise<number>;
+/**
+ * Update the feedback (like/dislike) for a message.
+ * Each regenerated response can have its own independent feedback.
+ *
+ * @param ctx - Storage operations context
+ * @param uniqueId - The unique ID of the message to update
+ * @param feedback - 'like', 'dislike', or null to clear feedback
+ * @returns The updated message or null if not found
+ */
+declare function updateMessageFeedbackOp(ctx: StorageOperationsContext, uniqueId: string, feedback: MessageFeedback): Promise<StoredMessage | null>;
+declare function searchMessagesOp(ctx: StorageOperationsContext, queryVector: number[], options?: {
+    limit?: number;
+    minSimilarity?: number;
+    conversationId?: string;
+}): Promise<StoredMessageWithSimilarity[]>;
+/**
+ * Decrypted, model-native chunk vectors for one message, cached across recall
+ * calls so the chunk lane doesn't re-decrypt + re-JSON.parse every message's
+ * embeddings on every query. Keyed by message id; `version` is the message's
+ * `updated_at` at cache time, so a re-embed (which bumps `updated_at`) misses
+ * and repopulates. Vectors are stored Float32 — model-native precision, half
+ * the RAM of float64 `number[]` — mirroring the vault embedding cache (#705).
+ * Content text is deliberately NOT cached (see searchChunksOp): it isn't
+ * needed for scoring, and keeping decrypted content out of the cache preserves
+ * the SDK's data-at-rest posture.
+ */
+interface CachedChunkVectors {
+    /** Message `updated_at` (ms) at cache time — the invalidation token. */
+    version: number;
     /**
-     * Activity phases for tracking the request lifecycle in the UI.
-     * Each phase represents a step like "Searching", "Thinking", "Generating".
-     * The final phase is automatically marked as completed when stored.
-     *
-     * Note: If you need activity phases that are added during streaming (e.g., server tool calls),
-     * use `getThoughtProcess` callback instead, which captures phases AFTER streaming completes.
+     * Per-chunk embedding vectors, index-aligned with the message's decrypted
+     * `chunks` array (empty-vector chunks kept as zero-length placeholders so
+     * indices stay aligned). Empty when the message has only a whole-message
+     * `fallback` vector.
      */
-    thoughtProcess?: ActivityPhase[];
+    chunks: Float32Array[];
+    /** Whole-message vector when the message was embedded without chunking. */
+    fallback?: Float32Array;
+}
+/**
+ * Cache consumed by {@link searchChunksOp}, keyed by message id. A plain `Map`
+ * (satisfied by the LRU from `createChunkVectorCache`) — mirrors
+ * `VaultEmbeddingCache` so consumers get the same `clear()`/`delete()`
+ * ergonomics on an encryption-key reset.
+ */
+type ChunkVectorCache = Map<string, CachedChunkVectors>;
+/** Row counts from one {@link searchChunksOp} call. */
+interface ChunkSearchStats {
+    /** Embedded messages in live conversations that the search considered. */
+    rowsScanned: number;
+    /** Messages whose vectors were read from storage because the cache missed. */
+    rowsFetched: number;
+    /** Messages scored straight from the vector cache. */
+    cacheHits: number;
+}
+/**
+ * Search through message chunks for fine-grained semantic search.
+ * Returns the matching chunk text along with the parent message.
+ */
+declare function searchChunksOp(ctx: StorageOperationsContext, queryVector: number[], options?: {
+    limit?: number;
+    minSimilarity?: number;
+    conversationId?: string;
+    /** Skip every message in this conversation before scoring. */
+    excludeConversationId?: string;
+    /** Current embedding model; messages stored under a different non-null model are skipped. */
+    embeddingModel?: string;
+    /** Decrypted-vector cache, validated by `updated_at`. */
+    chunkCache?: ChunkVectorCache;
+    /** Receives row counts for the call. */
+    onStats?: (stats: ChunkSearchStats) => void;
+}): Promise<ChunkSearchResult[]>;
+/**
+ * Get all files from all conversations, sorted by creation date (newest first).
+ * Returns files with conversation context for building file browser UIs.
+ */
+declare function getAllFilesOp(ctx: StorageOperationsContext, options?: {
+    /** Filter files by conversation ID */
+    conversationId?: string;
+    /** Maximum number of files to return */
+    limit?: number;
+}): Promise<StoredFileWithContext[]>;
+
+/**
+ * Types for the conversation-memory storage module.
+ *
+ * A conversation-memory row links a conversation to a vault memory it drew on,
+ * so the conversation Memories panel survives reload. Only the memory id and
+ * recall score are stored; content lives in the encrypted memory_vault.
+ */
+/** Plain object representation of a conversation-memory record. */
+interface StoredConversationMemory {
+    /** WatermelonDB internal ID */
+    uniqueId: string;
+    /** The conversation this memory was drawn on in */
+    conversationId: string;
+    /** The memory_vault record id this row points at */
+    memoryId: string;
+    /** Recall relevance score (~0–1) at the time it was recorded */
+    score: number;
+    createdAt: Date;
+}
+/** One memory drawn on during a turn, passed to addConversationMemoriesOp. */
+interface ConversationMemoryInput {
+    memoryId: string;
+    score: number;
+}
+
+/**
+ * Minimal interface for an observable (reactive) query result.
+ *
+ * Shaped to be compatible with RxJS-style `Observable` (which is what
+ * WatermelonDB returns) and with a simple polling fallback, so non-reactive
+ * backends can implement it without depending on rxjs.
+ */
+interface ChatStorageObservable<T> {
+    subscribe(observer: {
+        next: (value: T) => void;
+        error?: (err: unknown) => void;
+        complete?: () => void;
+    }): {
+        unsubscribe: () => void;
+    };
+}
+/**
+ * Common filter options for conversation queries. Kept deliberately narrow —
+ * most call sites only need these.
+ */
+interface ConversationQueryOptions {
+    /** If set, only return conversations in this project. `null` = no project. */
+    projectId?: string | null;
+}
+/**
+ * Backend-agnostic interface for chat/conversation storage.
+ *
+ * The method set mirrors the operations we actually use across the SDK:
+ * `*Op` functions in `src/lib/db/chat/operations.ts` plus the `observe*`
+ * patterns used by react hooks. Targeted updates (e.g., `updateMessageError`)
+ * are exposed as separate methods rather than a generic `update()` because
+ * several of them have special semantics (encryption bypass for embeddings,
+ * unique constraints on feedback, etc).
+ */
+interface ChatStorageAdapter {
+    getConversation(conversationId: string): Promise<StoredConversation | null>;
+    getConversations(options?: ConversationQueryOptions): Promise<StoredConversation[]>;
+    createConversation(options?: CreateConversationOptions): Promise<StoredConversation>;
+    updateConversationTitle(conversationId: string, title: string): Promise<boolean>;
+    updateConversationProject(conversationId: string, projectId: string | null): Promise<boolean>;
+    /** Pin or unpin a conversation. Pinning stamps `pinnedAt`; list queries are
+     * NOT reordered — consumers sort pinned chats first using `pinnedAt`. */
+    updateConversationPinned(conversationId: string, pinned: boolean): Promise<boolean>;
+    /** Soft delete. Implementations are responsible for cascading to messages/media. */
+    deleteConversation(conversationId: string): Promise<boolean>;
+    observeConversations(options?: ConversationQueryOptions): ChatStorageObservable<StoredConversation[]>;
+    getMessages(conversationId: string): Promise<StoredMessage[]>;
     /**
-     * Callback to get activity phases AFTER streaming completes.
-     * Use this instead of `thoughtProcess` when phases are added dynamically during streaming
-     * (e.g., via server tool call events like "Searching...", "Generating image...").
+     * Paginated display read: newest `limit` messages (optionally below
+     * `beforeMessageId`), ascending, with embeddings skipped. See
+     * `getMessagesPageOp`.
      *
-     * If both `thoughtProcess` and `getThoughtProcess` are provided, `getThoughtProcess` takes precedence.
-     */
-    getThoughtProcess?: () => ActivityPhase[];
-    /**
-     * Controls randomness in the response (0.0 to 2.0).
-     * Lower values make output more deterministic, higher values more creative.
-     */
-    temperature?: number;
-    /**
-     * Maximum number of tokens to generate in the response.
-     * Use this to limit response length and control costs.
+     * Optional so this is an additive, non-breaking interface change (same
+     * rationale as {@link updateMessageFileIds}). The default
+     * {@link WatermelonChatStorageAdapter} provides it.
      */
-    maxOutputTokens?: number;
+    getMessagesPage?(conversationId: string, options: GetMessagesPageOptions): Promise<StoredMessage[]>;
     /**
-     * Client-side tools with optional executors.
-     * These tools run in the browser/app and can have JavaScript executor functions.
+     * Whole-thread branch-tree skeleton (no decrypt). See
+     * `getMessageSkeletonsOp`. Optional for the same additive-change rationale.
      */
-    clientTools?: LlmapiChatCompletionTool[];
+    getMessageSkeletons?(conversationId: string): Promise<MessageSkeleton[]>;
+    /** Total message count for a conversation. Optional (additive change). */
+    getMessageCount?(conversationId: string): Promise<number>;
+    createMessage(options: CreateMessageOptions): Promise<StoredMessage>;
+    updateMessageEmbedding(uniqueId: string, vector: number[], embeddingModel: string): Promise<StoredMessage | null>;
+    updateMessageChunks(uniqueId: string, chunks: MessageChunk[], embeddingModel: string): Promise<StoredMessage | null>;
+    updateMessageError(uniqueId: string, error: string): Promise<StoredMessage | null>;
+    updateMessageFeedback(uniqueId: string, feedback: MessageFeedback): Promise<StoredMessage | null>;
     /**
-     * Server-side tools to include from /api/v1/tools.
-     * - undefined: Include all server-side tools (default)
-     * - string[]: Include only tools with these names
-     * - []: Include no server-side tools
-     * - function: Dynamic filter that receives prompt embedding(s) and all tools,
-     *   returns tool names to include. Useful for semantic tool matching.
-     *
-     * @example
-     * // Include only specific server tools
-     * serverTools: ["anuma_create_image", "perplexity_search"]
-     *
-     * // Disable server tools for this request
-     * serverTools: []
+     * Replace a message's attached media ids (`fileIds`). Used to attach a
+     * generated artifact (e.g. a rendered document PDF) to the assistant message
+     * that produced it, after streaming. Pass the FULL desired list.
      *
-     * // Semantic tool matching based on prompt
-     * serverTools: (embeddings, tools) => {
-     *   const matches = findMatchingTools(embeddings, tools, { limit: 5 });
-     *   return matches.map(m => m.tool.name);
-     * }
+     * Optional so this is an additive, non-breaking interface change: only hosts
+     * wiring document/artifact generation need it, and existing custom adapters
+     * keep compiling without implementing it. The default
+     * {@link WatermelonChatStorageAdapter} provides it.
      */
-    serverTools?: ServerToolsFilter;
+    updateMessageFileIds?(uniqueId: string, fileIds: string[]): Promise<StoredMessage | null>;
+    /** Clears all messages in a conversation (used for the "clear chat" action). */
+    clearMessages(conversationId: string): Promise<void>;
+    observeMessages(conversationId: string): ChatStorageObservable<StoredMessage[]>;
+    getAllFiles(): Promise<StoredFileWithContext[]>;
     /**
-     * Dynamic filter for client-side tools based on prompt embeddings.
-     * Receives the prompt embedding(s) (or null for short messages) and all client tools,
-     * returns tool names to include. Tools not in the returned list are excluded from the request.
+     * Run a set of mutations inside a single write transaction. Any mutation
+     * calls made on the adapter inside the callback are grouped into one atomic
+     * write on backends that support it.
      *
-     * @example
-     * clientToolsFilter: (embeddings, tools) => {
-     *   if (!embeddings) return []; // Short message — no client tools
-     *   const matches = findMatchingTools(embeddings, pseudoServerTools);
-     *   return matches.map(m => m.tool.name);
-     * }
-     */
-    clientToolsFilter?: ClientToolsFilterFn;
-    /**
-     * Controls which tool the model should use:
-     * - "auto": Model decides whether to use a tool (default)
-     * - "any": Model must use one of the provided tools
-     * - "none": Model cannot use any tools
-     * - "required": Model must use a tool
-     * - Specific tool name: Model must use that specific tool
-     */
-    toolChoice?: string;
-    /**
-     * Maximum number of tool execution rounds before forcing the model to respond with text.
-     * After this many rounds, `toolChoice` is set to `"none"` on the next continuation,
-     * so the model produces a text answer using whatever tool results it has gathered.
-     * @default 3
-     */
-    maxToolRounds?: number;
-    /**
-     * Reasoning configuration for o-series and other reasoning models.
-     * Controls reasoning effort level and whether to include reasoning summary.
-     */
-    reasoning?: LlmapiResponseReasoning;
-    /**
-     * Extended thinking configuration for Anthropic models (Claude).
-     * Enables the model to think through complex problems step by step
-     * before generating the final response.
-     */
-    thinking?: LlmapiThinkingOptions;
-    /** User-selected image generation model for server-side enforcement. */
-    imageModel?: string;
-    /**
-     * Per-request callback for thinking/reasoning chunks.
-     * Called with delta chunks as the model "thinks" through a problem.
-     * Use this to display thinking progress in the UI.
-     */
-    onThinking?: (chunk: string) => void;
-    /** Parent message ID for branching (edit/regenerate). Sets on the user message. */
-    parentMessageId?: string;
-    /**
-     * Pre-generated unique ID for the assistant response message.
-     * When provided, the persisted assistant message will use this ID instead of
-     * an auto-generated one. This lets the consumer show an in-flight streaming
-     * placeholder under the same React key, avoiding an unmount/remount flash
-     * when streaming completes and the message is loaded from the database.
+     * On backends without transaction support, this may fall back to sequential
+     * writes. Implementations must document the guarantee they provide.
      */
-    assistantUniqueId?: string;
+    write<T>(fn: (adapter: ChatStorageAdapter) => Promise<T>): Promise<T>;
 }
-interface BaseUseChatStorageResult {
-    isLoading: boolean;
-    stop: () => void;
-    conversationId: string | null;
-    setConversationId: (id: string | null) => void;
-    createConversation: (options?: CreateConversationOptions) => Promise<StoredConversation>;
-    getConversation: (id: string) => Promise<StoredConversation | null>;
-    getConversations: () => Promise<StoredConversation[]>;
-    updateConversationTitle: (id: string, title: string) => Promise<boolean>;
-    updateConversationPinned: (id: string, pinned: boolean) => Promise<boolean>;
-    deleteConversation: (id: string) => Promise<boolean>;
-    getMessages: (conversationId: string) => Promise<StoredMessage[]>;
-    /**
-     * Paginated display read: the newest `limit` messages (optionally below
-     * `beforeMessageId`), ascending, with embedding columns skipped.
-     */
-    getMessagesPage: (conversationId: string, options: GetMessagesPageOptions) => Promise<StoredMessage[]>;
-    /** Whole-thread branch-tree skeleton — no field decryption. */
-    getMessageSkeletons: (conversationId: string) => Promise<MessageSkeleton[]>;
-    /** Total message count for a conversation. */
-    getMessageCount: (conversationId: string) => Promise<number>;
+
+interface ChatChunkSearchOptions {
+    limit?: number;
+    minSimilarity?: number;
+    conversationId?: string;
+    excludeConversationId?: string;
+    embeddingModel?: string;
+    chunkCache?: ChunkVectorCache;
+    onStats?: (stats: ChunkSearchStats) => void;
+}
+/** Everything `useChatStorage` reads and writes for chats, so a hook can run on local or server storage. */
+interface ChatBackend extends ChatStorageAdapter {
+    createConversation(options?: CreateConversationOptions, defaultTitle?: string): Promise<StoredConversation>;
+    getAllFiles(options?: Parameters<typeof getAllFilesOp>[1]): Promise<StoredFileWithContext[]>;
+    getMessagesPage(conversationId: string, options: GetMessagesPageOptions): Promise<StoredMessage[]>;
+    getMessageSkeletons(conversationId: string): Promise<MessageSkeleton[]>;
+    /** Reads messages by id in the order asked, leaving out ids that are not stored. */
+    getMessagesByIds(uniqueIds: readonly string[]): Promise<StoredMessage[]>;
+    getMessageCount(conversationId: string): Promise<number>;
+    getToolCallEventIds(conversationId: string): Promise<Set<string>>;
+    upsertMessage(options: CreateMessageOptions & {
+        uniqueId: string;
+    }): Promise<StoredMessage>;
+    searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
+    upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
+    deleteSummary(conversationId: string): Promise<void>;
+    deleteMessage(uniqueId: string): Promise<string | null>;
+    getMemoryLinks(conversationId: string): Promise<StoredConversationMemory[]>;
+    /** Records the memories a turn drew on in recall order, moving already-linked ones to this turn with their new score. */
+    addMemoryLinks(conversationId: string, items: ConversationMemoryInput[]): Promise<void>;
+    clearMemoryLinks(conversationId: string): Promise<void>;
+}
+interface ChatBackendSigner {
+    walletAddress?: string;
+    signMessage?: SignMessageFn;
+    embeddedWalletSigner?: EmbeddedWalletSignerFn;
+}
+/** Builds the chat backend for a signer; `useChatStorage` calls it for live writes and for queued writes replayed later. */
+type ChatBackendFactory = (signer: ChatBackendSigner) => ChatBackend;
+
+/** Durable home for sealed outbox slots, one per running backend, so writes survive a reload while vault is unreachable. */
+interface ChatOutboxStorage {
+    slots(): Promise<string[]>;
+    get(slot: string): Promise<string | null>;
+    set(slot: string, sealed: string | null): Promise<void>;
+}
+/** The part of the Web Locks API the outbox uses to tell a live tab's slot from an orphaned one. */
+interface ChatOutboxLocks {
+    request<T>(name: string, options: {
+        ifAvailable?: boolean;
+    }, callback: (lock: object | null) => Promise<T> | T): Promise<T>;
 }
-declare function generateConversationId(): string;
 
-declare class Message extends Model {
+/** A change to the cached chats; `origin` is "remote" when another device or tab made it. */
+type VaultChatEvent = {
+    type: "conversations";
+    origin: "local" | "remote";
+} | {
+    type: "messages";
+    conversationId: string;
+    origin: "local" | "remote";
+} | {
+    type: "summary";
+    conversationId: string;
+    origin: "local" | "remote";
+} | {
+    type: "links";
+    conversationId: string;
+    origin: "local" | "remote";
+} | {
+    type: "outbox";
+    pending: number;
+    stopped?: string;
+} | {
+    type: "dropped";
+    kind: ChatRecordKind;
+    id: string;
+    reason: "missing" | "storage_quota" | "invalid" | "conversation_deleted";
+} | {
+    type: "vector_quota";
+};
+interface VaultChatActivity {
+    isActive(): boolean;
+    subscribe(onChange: () => void): () => void;
+}
+interface VaultChatBackendOptions {
+    store: ChatStore;
+    /** Persists unsent writes, sealed with `seal`, so they survive a reload; `locks` defaults to `navigator.locks`. */
+    outbox?: {
+        storage: ChatOutboxStorage;
+        seal: Pick<SealingCipher, "encrypt" | "decrypt">;
+        locks?: ChatOutboxLocks;
+    };
+    activity?: VaultChatActivity;
+    /** Polls `/changes` this often while active; 0 polls only on activity and broadcast hints. */
+    pollIntervalMs?: number;
+    /** BroadcastChannel name shared by this account's tabs, so one tab's writes prompt the others to poll. */
+    channel?: string;
+    threadCacheSize?: number;
+    now?: () => number;
+}
+interface SealingCipher {
+    encrypt(plaintext: string): Promise<string>;
+    decrypt(ciphertext: string): Promise<string>;
+}
+/** A {@link ChatBackend} over vault: a cache, an optimistic outbox and a change poller. */
+interface VaultChatBackend extends ChatBackend {
+    subscribe(listener: (event: VaultChatEvent) => void): () => void;
+    /** Sends queued writes now; resolves once the outbox is empty, waiting on a retry, or stopped. */
+    flush(): Promise<void>;
+    /** Applies changes other devices made since the last poll. */
+    poll(): Promise<void>;
+    status(): {
+        pending: number;
+        stopped?: string;
+    };
+    close(): void;
+}
+/** Creates a vault chat backend for one account and key; build a new one after a wallet or key change. */
+declare function createVaultChatBackend(options: VaultChatBackendOptions): VaultChatBackend;
+/** A {@link ChatBackendFactory} that hands `useChatStorage` the same vault backend for every signer. */
+declare function vaultChatBackend(backend: VaultChatBackend): ChatBackendFactory;
+
+declare class AppFile extends Model {
     static table: string;
     static associations: Associations;
-    messageId: number;
     conversationId: string;
-    role: ChatRole;
+    path: string;
     content: string;
-    model?: string;
-    imageModel?: string;
-    /** @deprecated Use fileIds with media table instead */
-    files?: FileMetadata[];
-    /** Array of media_id references for direct lookup */
-    fileIds?: string[];
     createdAt: Date;
     updatedAt: Date;
-    vector?: number[];
-    embeddingModel?: string;
-    chunks?: MessageChunk[];
-    usage?: ChatCompletionUsage;
-    sources?: SearchSource[];
-    responseDuration?: number;
-    wasStopped?: boolean;
-    error?: string;
-    thoughtProcess?: ActivityPhase[];
-    thinking?: string;
-    parentMessageId?: string;
-    feedback?: MessageFeedback;
-    toolCallEvents?: LlmapiToolCallEvent[];
-    /** Plaintext by design — see MessageOrigin */
-    origin?: MessageOrigin;
 }
-declare class Conversation extends Model {
-    static table: string;
-    static associations: Associations;
+
+/**
+ * Types for the app files storage module.
+ *
+ * App files are the HTML/CSS/JS source files for LLM-generated apps,
+ * stored per conversation. Each file is identified by a conversationId + path pair.
+ */
+/** Plain object representation of an app file record. */
+interface StoredAppFile {
+    /** WatermelonDB internal ID */
+    uniqueId: string;
+    /** The conversation this file belongs to */
     conversationId: string;
-    title: string;
-    projectId?: string;
+    /** Normalized file path, no leading slash (e.g. "index.html", "src/App.tsx") */
+    path: string;
+    /** File content (UTF-8 text) */
+    content: string;
     createdAt: Date;
     updatedAt: Date;
-    isDeleted: boolean;
-    /** When the conversation was pinned to the top of the list; null/unset = not pinned.
-     * `null` (not `undefined`) at runtime for unpinned rows — `@date` maps a null raw
-     * column to null, and unpin stores an explicit null. */
-    pinnedAt?: Date | null;
 }
 
+/** Context required by app file operations. */
+interface AppFileOperationsContext {
+    database: Database;
+    appFilesCollection: Collection<AppFile>;
+}
+/** Convert a WatermelonDB AppFile model to a plain StoredAppFile object. */
+declare function appFileToStored(file: AppFile): StoredAppFile;
+/**
+ * Create or overwrite a file. If a file with the same conversationId + path
+ * already exists, it is updated in place.
+ */
+declare function putAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string, content: string): Promise<StoredAppFile>;
+/** Read a single file by conversationId and path. Returns null if not found. */
+declare function getAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string): Promise<StoredAppFile | null>;
+/** List all files for a conversation. */
+declare function getAppFilesOp(ctx: AppFileOperationsContext, conversationId: string): Promise<StoredAppFile[]>;
+/** Get all files for a conversation as a path → content map (for sending to the runner). */
+declare function getAppFileMapOp(ctx: AppFileOperationsContext, conversationId: string): Promise<Record<string, string>>;
+/** Delete a single file by conversationId and path. */
+declare function deleteAppFileOp(ctx: AppFileOperationsContext, conversationId: string, path: string): Promise<boolean>;
+/** Delete all files for a conversation. */
+declare function deleteAllAppFilesOp(ctx: AppFileOperationsContext, conversationId: string): Promise<void>;
+
+/**
+ * Drop every cached plaintext title and pending decrypt promise.
+ *
+ * Wired into `clearAllEncryptionState()` via the listener registry in
+ * `useEncryption.ts`. Also exported so consumers can clear the cache
+ * proactively (e.g. on wallet switch within a session before the
+ * full encryption-state teardown lands).
+ */
+declare function clearLazyTitleCache(): void;
+/**
+ * Decrypt a single conversation title on demand.
+ *
+ * Designed for the lazy display path: pair with `listConversationsLazy`
+ * and call this once a row is actually visible.
+ *
+ * Behavior:
+ *   - Plaintext input (no `enc:` prefix) is returned unchanged. This
+ *     covers conversations created before encryption was enabled and
+ *     keeps the helper safe to call unconditionally from rendering
+ *     code that may receive a mix of encrypted and plaintext titles.
+ *   - Encrypted input is decrypted via `decryptField`, which uses the
+ *     same per-version cached `CryptoKey` as the eager path — no new
+ *     key derivations are triggered.
+ *   - Concurrent calls for the same `(address, encryptedTitle)` share
+ *     a single decrypt promise.
+ *   - The result is memoized in a 256-entry LRU.
+ *
+ * Throws if the encryption key for `address` isn't loaded. (The
+ * underlying `decryptField` would otherwise silently return the
+ * ciphertext, which would surface to the UI as a literal `enc:v3:...`
+ * title — strictly worse than a thrown error the caller can catch.)
+ *
+ * @param encryptedTitle - The stored title. May be ciphertext or plaintext.
+ * @param address - Wallet address that owns the encryption key.
+ * @returns The decrypted plaintext title.
+ */
+declare function decryptConversationTitle(encryptedTitle: string, address: string): Promise<string>;
+
 declare const chatStorageSchema: Readonly<{
     version: _nozbe_watermelondb_Schema.SchemaVersion;
     tables: _nozbe_watermelondb_Schema.TableMap;
@@ -9231,31 +9558,6 @@ declare class ConversationMemory extends Model {
     createdAt: Date;
 }
 
-/**
- * Types for the conversation-memory storage module.
- *
- * A conversation-memory row links a conversation to a vault memory it drew on,
- * so the conversation Memories panel survives reload. Only the memory id and
- * recall score are stored; content lives in the encrypted memory_vault.
- */
-/** Plain object representation of a conversation-memory record. */
-interface StoredConversationMemory {
-    /** WatermelonDB internal ID */
-    uniqueId: string;
-    /** The conversation this memory was drawn on in */
-    conversationId: string;
-    /** The memory_vault record id this row points at */
-    memoryId: string;
-    /** Recall relevance score (~0–1) at the time it was recorded */
-    score: number;
-    createdAt: Date;
-}
-/** One memory drawn on during a turn, passed to addConversationMemoriesOp. */
-interface ConversationMemoryInput {
-    memoryId: string;
-    score: number;
-}
-
 /** Context required by conversation-memory operations. */
 interface ConversationMemoryOperationsContext {
     database: Database;
@@ -12594,7 +12896,7 @@ declare function cosineInt8(a: Int8Array, scaleA: number, b: Int8Array, scaleB:
  * The tool allows the LLM to search through past conversation messages
  * using semantic similarity. Messages must have embeddings stored to be searchable.
  *
- * @param storageCtx - Storage operations context for database access
+ * @param storage - Chat storage: a WatermelonDB operations context or a chat backend
  * @param embeddingOptions - Options for embedding generation
  * @param searchOptions - Default search options (can be overridden per-call)
  * @returns A ToolConfig that can be passed to chat completion tools
@@ -12614,7 +12916,7 @@ declare function cosineInt8(a: Int8Array, scaleA: number, b: Int8Array, scaleB:
  * });
  * ```
  */
-declare function createMemoryEngineTool(storageCtx: StorageOperationsContext, embeddingOptions: EmbeddingOptions, searchOptions?: Partial<MemoryEngineSearchOptions>, callbacks?: {
+declare function createMemoryEngineTool(storage: StorageOperationsContext | Pick<ChatBackend, "searchChunks" | "getMessages">, embeddingOptions: EmbeddingOptions, searchOptions?: Partial<MemoryEngineSearchOptions>, callbacks?: {
     /** Called after retrieval with the conversation IDs that were actually returned to the LLM. */
     onRetrieve?: (conversationIds: string[]) => void;
 }): ToolConfig;
@@ -13081,101 +13383,6 @@ declare class ZipProcessor implements FileProcessor {
     private guessMimeType;
 }
 
-/**
- * Minimal interface for an observable (reactive) query result.
- *
- * Shaped to be compatible with RxJS-style `Observable` (which is what
- * WatermelonDB returns) and with a simple polling fallback, so non-reactive
- * backends can implement it without depending on rxjs.
- */
-interface ChatStorageObservable<T> {
-    subscribe(observer: {
-        next: (value: T) => void;
-        error?: (err: unknown) => void;
-        complete?: () => void;
-    }): {
-        unsubscribe: () => void;
-    };
-}
-/**
- * Common filter options for conversation queries. Kept deliberately narrow —
- * most call sites only need these.
- */
-interface ConversationQueryOptions {
-    /** If set, only return conversations in this project. `null` = no project. */
-    projectId?: string | null;
-}
-/**
- * Backend-agnostic interface for chat/conversation storage.
- *
- * The method set mirrors the operations we actually use across the SDK:
- * `*Op` functions in `src/lib/db/chat/operations.ts` plus the `observe*`
- * patterns used by react hooks. Targeted updates (e.g., `updateMessageError`)
- * are exposed as separate methods rather than a generic `update()` because
- * several of them have special semantics (encryption bypass for embeddings,
- * unique constraints on feedback, etc).
- */
-interface ChatStorageAdapter {
-    getConversation(conversationId: string): Promise<StoredConversation | null>;
-    getConversations(options?: ConversationQueryOptions): Promise<StoredConversation[]>;
-    createConversation(options?: CreateConversationOptions): Promise<StoredConversation>;
-    updateConversationTitle(conversationId: string, title: string): Promise<boolean>;
-    updateConversationProject(conversationId: string, projectId: string | null): Promise<boolean>;
-    /** Pin or unpin a conversation. Pinning stamps `pinnedAt`; list queries are
-     * NOT reordered — consumers sort pinned chats first using `pinnedAt`. */
-    updateConversationPinned(conversationId: string, pinned: boolean): Promise<boolean>;
-    /** Soft delete. Implementations are responsible for cascading to messages/media. */
-    deleteConversation(conversationId: string): Promise<boolean>;
-    observeConversations(options?: ConversationQueryOptions): ChatStorageObservable<StoredConversation[]>;
-    getMessages(conversationId: string): Promise<StoredMessage[]>;
-    /**
-     * Paginated display read: newest `limit` messages (optionally below
-     * `beforeMessageId`), ascending, with embeddings skipped. See
-     * `getMessagesPageOp`.
-     *
-     * Optional so this is an additive, non-breaking interface change (same
-     * rationale as {@link updateMessageFileIds}). The default
-     * {@link WatermelonChatStorageAdapter} provides it.
-     */
-    getMessagesPage?(conversationId: string, options: GetMessagesPageOptions): Promise<StoredMessage[]>;
-    /**
-     * Whole-thread branch-tree skeleton (no decrypt). See
-     * `getMessageSkeletonsOp`. Optional for the same additive-change rationale.
-     */
-    getMessageSkeletons?(conversationId: string): Promise<MessageSkeleton[]>;
-    /** Total message count for a conversation. Optional (additive change). */
-    getMessageCount?(conversationId: string): Promise<number>;
-    createMessage(options: CreateMessageOptions): Promise<StoredMessage>;
-    updateMessageEmbedding(uniqueId: string, vector: number[], embeddingModel: string): Promise<StoredMessage | null>;
-    updateMessageChunks(uniqueId: string, chunks: MessageChunk[], embeddingModel: string): Promise<StoredMessage | null>;
-    updateMessageError(uniqueId: string, error: string): Promise<StoredMessage | null>;
-    updateMessageFeedback(uniqueId: string, feedback: MessageFeedback): Promise<StoredMessage | null>;
-    /**
-     * Replace a message's attached media ids (`fileIds`). Used to attach a
-     * generated artifact (e.g. a rendered document PDF) to the assistant message
-     * that produced it, after streaming. Pass the FULL desired list.
-     *
-     * Optional so this is an additive, non-breaking interface change: only hosts
-     * wiring document/artifact generation need it, and existing custom adapters
-     * keep compiling without implementing it. The default
-     * {@link WatermelonChatStorageAdapter} provides it.
-     */
-    updateMessageFileIds?(uniqueId: string, fileIds: string[]): Promise<StoredMessage | null>;
-    /** Clears all messages in a conversation (used for the "clear chat" action). */
-    clearMessages(conversationId: string): Promise<void>;
-    observeMessages(conversationId: string): ChatStorageObservable<StoredMessage[]>;
-    getAllFiles(): Promise<StoredFileWithContext[]>;
-    /**
-     * Run a set of mutations inside a single write transaction. Any mutation
-     * calls made on the adapter inside the callback are grouped into one atomic
-     * write on backends that support it.
-     *
-     * On backends without transaction support, this may fall back to sequential
-     * writes. Implementations must document the guarantee they provide.
-     */
-    write<T>(fn: (adapter: ChatStorageAdapter) => Promise<T>): Promise<T>;
-}
-
 /**
  * Pure functions for extracting MCP media URLs (images and videos).
  *
@@ -13343,14 +13550,14 @@ interface WatermelonChatStorageAdapterOptions {
     /** Silent signing function for embedded wallets (optional). */
     embeddedWalletSigner?: EmbeddedWalletSignerFn;
 }
-declare class WatermelonChatStorageAdapter implements ChatStorageAdapter {
+declare class WatermelonChatStorageAdapter implements ChatBackend {
     private readonly ctx;
     private readonly messages;
     private readonly conversations;
     constructor(options: WatermelonChatStorageAdapterOptions);
     getConversation(conversationId: string): Promise<StoredConversation | null>;
     getConversations(options?: ConversationQueryOptions): Promise<StoredConversation[]>;
-    createConversation(options?: CreateConversationOptions): Promise<StoredConversation>;
+    createConversation(options?: CreateConversationOptions, defaultTitle?: string): Promise<StoredConversation>;
     updateConversationTitle(conversationId: string, title: string): Promise<boolean>;
     updateConversationProject(conversationId: string, projectId: string | null): Promise<boolean>;
     updateConversationPinned(conversationId: string, pinned: boolean): Promise<boolean>;
@@ -13358,6 +13565,7 @@ declare class WatermelonChatStorageAdapter implements ChatStorageAdapter {
     observeConversations(options?: ConversationQueryOptions): ChatStorageObservable<StoredConversation[]>;
     getMessages(conversationId: string): Promise<StoredMessage[]>;
     getMessagesPage(conversationId: string, options: GetMessagesPageOptions): Promise<StoredMessage[]>;
+    getMessagesByIds(uniqueIds: readonly string[]): Promise<StoredMessage[]>;
     getMessageSkeletons(conversationId: string): Promise<MessageSkeleton[]>;
     getMessageCount(conversationId: string): Promise<number>;
     createMessage(options: CreateMessageOptions): Promise<StoredMessage>;
@@ -13368,7 +13576,20 @@ declare class WatermelonChatStorageAdapter implements ChatStorageAdapter {
     updateMessageFileIds(uniqueId: string, fileIds: string[]): Promise<StoredMessage | null>;
     clearMessages(conversationId: string): Promise<void>;
     observeMessages(conversationId: string): ChatStorageObservable<StoredMessage[]>;
-    getAllFiles(): Promise<StoredFileWithContext[]>;
+    getAllFiles(options?: Parameters<typeof getAllFilesOp>[1]): Promise<StoredFileWithContext[]>;
+    getToolCallEventIds(conversationId: string): Promise<Set<string>>;
+    upsertMessage(options: CreateMessageOptions & {
+        uniqueId: string;
+    }): Promise<StoredMessage>;
+    searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
+    upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
+    deleteSummary(conversationId: string): Promise<void>;
+    deleteMessage(uniqueId: string): Promise<string | null>;
+    getMemoryLinks(conversationId: string): Promise<StoredConversationMemory[]>;
+    addMemoryLinks(conversationId: string, items: ConversationMemoryInput[]): Promise<void>;
+    clearMemoryLinks(conversationId: string): Promise<void>;
+    private memoryCtx;
     /**
      * WatermelonDB nests `database.write()` safely: each method we call inside
      * the callback already wraps its own writes, and Watermelon collapses the
@@ -13377,6 +13598,7 @@ declare class WatermelonChatStorageAdapter implements ChatStorageAdapter {
      */
     write<T>(fn: (adapter: ChatStorageAdapter) => Promise<T>): Promise<T>;
 }
+declare function localChatBackend(database: Database): ChatBackendFactory;
 
 type WhisperModel = "whisper-tiny" | "whisper-tiny.en" | "whisper-base" | "whisper-base.en" | "whisper-small" | "whisper-small.en";
 interface VoiceRecording {
@@ -15964,4 +16186,4 @@ type UseWalletBindingResult = {
  */
 declare function useWalletBinding(options?: UseWalletBindingOptions): UseWalletBindingResult;
 
-export { Anuma, type AnumaChild, AnumaJsxError, type AnumaNode, AnumaShadowIsolationProvider, type AnumaShadowIsolationProviderProps, type AnumaTheme, AnumaThemeProvider, type AnumaThemeProviderProps, AppFile as AppFileModel, type AppFileOperationsContext, type AttrValue, type AutoExtractMessage, type AutoExtractor, DEFAULT_BACKUP_FOLDER as BACKUP_ICLOUD_FOLDER, BUILT_IN_TOOL_SETS, type BackupAuthContextValue, BackupAuthProvider, type BackupAuthProviderProps, type BackupOperationOptions, BlobUrlManager, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, ChartCard, type ChartCardProps, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, type ChatAccount, type ChatAccountState, type ChatAttachment, type ChatAttachments, type ChatChanges, Conversation as ChatConversation, type ChatImport, type ChatJson, type ChatListOptions, Message as ChatMessage, type ChatPage, type ChatPresignedUrl, type ChatRecord, type ChatRecordKind, type ChatRef, type ChatRevision, type ChatRole, type ChatSearchHit, type ChatSearchOptions, type ChatSnapshot, type ChatStorageAdapter, type ChatStorageObservable, type ChatStore, ChatStoreError, type ChatWrite, type ChunkSearchResult, type ChunkSearchStats, type ChunkVectorCache, type ChunkingOptions, type CircleProps, type ClientToolsFilterFn, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type ConversationQueryOptions, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateEntityOptions, type CreateMediaOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, type CreateProjectOptions, type CreateSavedToolOptions, type CreateSelectPaymentWalletToolOptions, type CreateServerToolsFilterOptions, type CreateUserPreferenceOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CreateWalletPaymentToolOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_EXCLUDED_SERVER_TOOLS, DEFAULT_BACKUP_FOLDER as DEFAULT_ICLOUD_BACKUP_FOLDER, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PERSONALITY_SETTINGS, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_SERVER_TOOLS_MATCH_OPTIONS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DeckProps, type DisplayToolMigrations, type DurableAutoExtractorOptions, ENTITY_FANOUT, ENTITY_KINDS, type EmbeddedWalletSignerFn, type EmbeddingRepairOptions, type EmbeddingRepairResult, EncryptionKeyMissingError, type EncryptionKeyVersion, type EntityInput, type EntityKind, Entity as EntityModel, type EntityOperationsContext, ExcelProcessor, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionMessageSource, type ExtractionSourceMessage, type ExtractionSourceStatus, type ExtractionTimings, FILE_PLACEHOLDER_PREFIX, FILE_PLACEHOLDER_REGEX, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FileProcessor, type FileTypeQuery, type FileWithData, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, type GroupProps, HARD_DELETE_WINDOW_MS, type ICloudAuthContextValue, ICloudAuthProvider, type ICloudAuthProviderProps, type ICloudExportResult, type ICloudImportResult, INFERENCE_ID_HEADER, INTERNAL_FLOW_MARKER, type IconProps, type ImageProps, type InjectionClassifierOptions, type InjectionReason, type InteractionType, type KnownTag, type LazyStoredConversation, type LineProps, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type LocalMemoryStoreOptions, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, MEMORY_KINDS, MEMORY_LEVELS, type ManualFactType, type MediaDimensions, type MediaFilterOptions, type MediaMetadata, type MediaOperationsContext, type MediaRole, type MediaType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type MemoryCounts, type MemoryCreate, type MemoryDecay, type MemoryDecaySweeperOptions, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, MemoryEntity as MemoryEntityModel, type MemoryExtractedEvent, MemoryKeyError, type MemoryKeyRing, type MemoryKind, type MemoryLevel, MemoryLevelError, type MemoryListOptions, type MemoryMaintenance, type MemoryMigrationOptions, type MemoryMigrationProgress, type MemoryMigrationResult, type MemoryMigrationSkip, type MemoryQuarantinedEvent, type MemoryRecallOptions, type MemoryRetainOptions, type MemoryStore, type MemorySubscribeOptions, type MemoryToVerify, type MemoryTopic, type MemoryTopicBacklog, type MemoryTopicMaintenance, type MemoryUpdate, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageChunk, type MessageFeedback, type MessageOrigin, type MessageSkeleton, type ModelLoadProgress, NEVER_TTL_MS, NODE_BUDGET, type NeighborRefiner, type NowSource, type OCRFile, type ObservationTrend, type ObservationTrendInput, type OperationExecutor, PAST_EVENT_GRACE_MS, PROFILE_DOC_VERSION, type ParsedServerToolsResponse, type PaymentWallet, type PdfExportOptions, type PdfExportProgress, type PdfExportStage, type PdfFile, PdfProcessor, type PendingInteraction, type PersonalitySettings, type PersonalitySliders, type PersonalityStyle, type PhoneCallPollingOptions, type PhotoIngestResult, type PhotoMediaRef, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type PreprocessingOptions, type PreprocessingResult, type ProcessedFileResult, ProcessorRegistry, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type ProfileUpdate, type ProgressCallback, Project, type ProjectOperationsContext, type PromptPreProcessor, type PromptPreProcessorContext, type ProviderAuthState, type ProviderBackupState, ProviderStreamError, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, type QueueEncryptionContext, QueueManager, type QueueStatus, type QueuedOperation, type QueuedOperationType, R2_DEFAULT_TTL_MS, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallTelemetryCallbacks, type RecallToolCallbacks, type RecallToolOptions, type RecallTruncation, type RecencyOptions, type RectProps, type ReflectOptions, type ReflectResult, type RemoteChatStoreOptions, type RemoteMemoryCandidateOptions, type RemoteMemoryDecodeFailure, RemoteMemoryError, type RemoteMemoryListOptions, type RemoteMemoryMetadataPage, type RemoteMemoryMetadataRecord, type RemoteMemoryPage, RemoteMemoryPartialCreateError, type RemoteMemoryPersistence, type RemoteMemoryPersistenceOptions, type RemoteMemoryPipeline, type RemoteMemoryPipelineOptions, type RemoteMemoryQueryOptions, type RemoteMemoryQueryPage, type RemoteMemoryReadFilters, type RemoteMemoryRecord, type RemoteMemoryRow, type RemoteMemoryStoreOptions, type RemoteMemoryTopic, type RemoteMemoryWorkKind, type RemoteMemoryWorkLease, type RemoteMemoryWorkPersistence, type RemoteTopicPersistence, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ReservationReceipt, type ResumeStreamOptions, type ResumeStreamResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SELECT_PAYMENT_WALLET_TOOL_NAME, SERVER_TOOL_DEPENDENCY_SETS, SHORT_TTL_MS, SLIDER_CONFIG, SLIDES_FILE_PATH, SLIDE_CANVAS_HEIGHT, SLIDE_CANVAS_WIDTH, STREAM_RESUMABLE_HEADER, SavedTool as SavedToolModel, type SavedToolOperationsContext, type SavedToolParameter, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenProps, type ScreenResult, type ScreenedCandidate, type SearchMessagesOptions, type SearchSource, type SelectPaymentWalletResult, type SelectServerToolsForPromptOptions, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type ServerTool, type ServerToolsFilter, type ServerToolsFilterFn, type ServerToolsFilterFunction, type ServerToolsOptions, type ServerToolsResponse, type SignMessageFn, type SignMessageOptions, type SlideProps, type StepFinishEvent, type StockPriceClassification, type StockPricePreProcessorOptions, type StorageOperationsContext, type StoredAppFile, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredEntity, type StoredFileWithContext, type StoredMedia, Media as StoredMediaModel, type StoredMessage, type StoredMessageWithSimilarity, type StoredModelPreference, ModelPreference as StoredModelPreferenceModel, type StoredProject, type StoredSavedTool, type StoredTopic, type StoredUserPreference, UserPreference as StoredUserPreferenceModel, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, THEME_ATTRS, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TOPIC_SALIENCE_WEIGHTS, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, TextProcessor, type TextProps, type ThemeAttr, type ToolCallArgumentsDeltaEvent, type ToolMatchOptions, type ToolMatchResult, type ToolSet, type TopicExtractOptions, type TopicExtractionBatchDiagnostics, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSalience, type TopicSkipReason, type TopicSource, type TranscriptionResult, type TurnCompleteEvent, type TurnSkippedEvent, type UIInteractionContextValue, UIInteractionProvider, type UIInteractionProviderProps, type UncheckedReason, type UnverifiableReason, type UpdateMediaOptions, type UpdateModelPreferenceOptions, type UpdateProjectOptions, type UpdateSavedToolOptions, type UpdateUserPreferenceOptions, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseBackupOptions, type UseBackupResult, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseEncryptionResult, type UseExportPdfResult, type UseFilesOptions, type UseFilesResult, type UseICloudBackupOptions, type UseICloudBackupResult, type UseModelsResult, type UseOCRResult, type UsePdfResult, type UsePhoneCallsOptions, type UsePhoneCallsResult, type UseProjectsOptions, type UseProjectsResult, type UseSettingsOptions, type UseSettingsResult, type UseSubscriptionOptions, type UseSubscriptionResult, type UseToolsOptions, type UseToolsResult, type UseVoiceOptions, type UseVoiceResult, type UseWalletBindingOptions, type UseWalletBindingResult, VAULT_SIZE_HOP_CAP, type VaultCandidateKey, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultMemoryKind, type VaultMemoryOperationsContext, type VaultMemoryProjection, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, type VoiceRecording, WALLET_PAYMENT_TOOL_NAME, type WalletPaymentOutcome, type WalletPaymentPassenger, type WalletPaymentRequest, type WalletPaymentResult, WalletPoller, WatermelonChatStorageAdapter, type WatermelonChatStorageAdapterOptions, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, type WhisperModel, WordProcessor, type WriteFailureReason, ZipProcessor, type ZipProcessorOptions, addConversationMemoriesOp, appFileToStored, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryEntityUserIdsOp, backfillMemoryTopicsOp, buildAttachedFilesText, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearAllKeyPairs, clearConversationMemoriesOp, clearEncryptionKey, clearICloudAuth, clearKeyPair, clearLazyTitleCache, clearMemoryTopicsOverrideOp, clearModelsCache, clearNotionToken, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createGitHubTools, createLlmDecayClassifier, createLlmNeighborRefiner, createLocalMemoryStore, createMediaBatchOp, createMediaOp, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createPlatformCursorStore, createProjectOp, createRecallTool, createRemoteChatStore, createRemoteMemoryPersistence, createRemoteMemoryPipeline, createRemoteMemoryStore, createSavedToolOp, createSelectPaymentWalletTool, createServerToolsFilter, createStockPricePreProcessor, createVaultEmbeddingCache, createVaultFolderOp, createVaultMemoriesBatchOp, createVaultMemoryOp, createWalletPaymentTool, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, decryptData, decryptDataBatch, decryptDataBytes, decryptDataBytesFromBytes, decryptDataWithKey, decryptMessageEmbeddingFields, defaultServerToolsFilter, deleteAllAppFilesOp, deleteAllVaultMemoriesForUserOp, deleteAppFileOp, deleteEncryptedFile, deleteMediaByConversationOp, deleteMediaByMessageOp, deleteMediaOp, deleteMessageOp, deleteProjectOp, deleteSavedToolOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, deriveMemoryKeyRing, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, encryptData, encryptDataBatch, encryptDataBytes, encryptDataWithKey, encryptToolCallEventsOp, ensureDefaultFoldersOp, expandToolSetsAdditive, exportElementToPdf, exportMarkdownToPdf, exportPublicKey, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, extractFileIds, extractMCPImageUrls, extractReservationReceipts, fileExists, findById, findMatchingTools, findParentOfId, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateMediaId, generateProjectId, getAIGeneratedMediaOp, getAllSavedToolsOp, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getAndClearNotionPendingMessage, getAndClearNotionReturnUrl, getAppFileMapOp, getAppFileOp, getAppFilesOp, getAudioOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsByProjectOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getDocumentsOp, getEncryptionKey, getEntitiesByMemoryIdsOp, getId, getImagesOp, getLogger, getMediaByConversationOp, getMediaByIdOp, getMediaByIdsOp, getMediaByMessageOp, getMediaByModelOp, getMediaByRoleOp, getMediaBySourceUrlOp, getMediaByTypeOp, getMediaCountOp, getMediaCountsByTypeOp, getMediaOp, getMediaTypeFromMime, getMemoriesByEntityNamesOp, getMemoriesNeedingTopicExtractionOp, getNotionAccessToken, getNotionMCPUrl, getNumberAttr, getProjectConversationCountOp, getProjectConversationsOp, getProjectOp, getProjectsOp, getRecentMediaOp, getSavedToolByIdOp, getServerTools, getStringAttr, getSupportedFileTypes, getToolsChecksum, getUnfiledVaultMemoriesOp, getUserUploadedMediaOp, getValidNotionToken, getVaultCandidateKeysOp, getVaultEmbeddingsByIdsOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, getVideosOp, handleNotionCallback, hardDeleteDecayedOp, hardDeleteMediaOp, hasEncryptionKey, hasICloudCredentials, hasKeyPair, hasNotionCredentials, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, insertAfterId, insertChild, isAnumaTag, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isHtmlTag, isNotionCallback, isOPFSSupported, isR2UrlExpired, isRerankerAvailable, isSupportedFile, isSupportedMediaType, linkMemoryEntitiesOp, maskScopedEmbeddingCache, mediaToStored, memoryCipher, migrateDisplayResult, migrateMemoriesToRemote, migrateNotionClientRegistration, migrateNotionToken, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, parseJsx, parseMedia, preEmbedVaultMemories, preprocessFiles, previewToolSelection, primaryTopic, projectToStored, putAppFileOp, quantizeEmbedding, queueManager, rankProfileCandidates, readEncryptedFile, recall, reencryptMemoryField, reflect, refreshEncryptionKeyIfMatches, refreshNotionToken, relinkMemoryTopicsOp, relinkMisclassifiedVideosOp, removeById, renderAnumaJsx, renderAnumaTree, renderElementToCanvas, replaceById, replaceMemoryEntitiesGuardedOp, requestEncryptionKey, requestKeyPair, resolveFilePlaceholders, resolveThemeColor, restoreVaultMemoryOp, resumeStream, retain, revokeNotionAccess, savedToolToStored, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, sealLegacyMessageEmbeddingsOp, searchChunksOp, searchMediaOp, searchMessagesOp, searchVaultMemories, seedEncryptionKeys, selectServerToolsForPrompt, serializeJsx, setLogger, setMemoryEntitiesOp, setMemoryVisibilityOp, settingsStorageSchema, shouldChunkMessage, shouldRecallMemory, shouldRefreshTools, stampTopicsExtractedAtOp, startNotionAuth, storeNotionPendingMessage, storeNotionReturnUrl, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, topicWeight, traverseGraphLane, ttlForType, updateAttrs, updateConversationProjectOp, updateMediaMessageIdBatchOp, updateMediaOp, updateMessageFeedbackOp, updateProjectNameOp, updateProjectOp, updateSavedToolOp, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, useAnumaTheme, useBackup, useBackupAuth, useChat, useChatStorage, useCredits, useDatabaseManager, useEncryption, useExportPdf, useFiles, useICloudAuth, useICloudBackup, useModels, useOCR, usePdf, usePhoneCalls, useProjects, useSettings, useSubscription, useTools, useUIInteraction, useVoice, useWalletBinding, userPreferencesStorageSchema, verifyMemoriesForPublish, walk, webPlatformStorage, withActiveToolSetServerTools, withInternalFlowMarker, writeEncryptedFile };
+export { Anuma, type AnumaChild, AnumaJsxError, type AnumaNode, AnumaShadowIsolationProvider, type AnumaShadowIsolationProviderProps, type AnumaTheme, AnumaThemeProvider, type AnumaThemeProviderProps, AppFile as AppFileModel, type AppFileOperationsContext, type AttrValue, type AutoExtractMessage, type AutoExtractor, DEFAULT_BACKUP_FOLDER as BACKUP_ICLOUD_FOLDER, BUILT_IN_TOOL_SETS, type BackupAuthContextValue, BackupAuthProvider, type BackupAuthProviderProps, type BackupOperationOptions, BlobUrlManager, type Budget, CHUNKS_DISCARDED_ORIGIN, type CachedChunkVectors, type CachedServerTools, ChartCard, type ChartCardProps, type ChartConfig, ChartContainer, ChartLegend, ChartLegendContent, ChartStyle, ChartTooltip, ChartTooltipContent, type ChatAccount, type ChatAccountState, type ChatAttachment, type ChatAttachments, type ChatBackend, type ChatBackendFactory, type ChatBackendSigner, type ChatChanges, type ChatChunkSearchOptions, Conversation as ChatConversation, type ChatImport, type ChatJson, type ChatListOptions, Message as ChatMessage, type ChatMigrationOptions, type ChatMigrationProgress, type ChatMigrationResult, type ChatMigrationSkip, type ChatOutboxLocks, type ChatOutboxStorage, type ChatPage, type ChatPresignedUrl, type ChatRecord, type ChatRecordKind, type ChatRef, type ChatRevision, type ChatRole, type ChatSearchHit, type ChatSearchOptions, type ChatSnapshot, type ChatStorageAdapter, type ChatStorageObservable, type ChatStore, ChatStoreError, type ChatWrite, type ChunkSearchResult, type ChunkSearchStats, type ChunkVectorCache, type ChunkingOptions, type CircleProps, type ClientToolsFilterFn, type ConsolidationAction, type ConsolidationFallbackReason, type ConversationMemoryInput, ConversationMemory as ConversationMemoryModel, type ConversationMemoryOperationsContext, type ConversationQueryOptions, type CreateAutoExtractorOptions, type CreateConversationOptions, type CreateDecaySweeperOptions, type CreateEntityOptions, type CreateMediaOptions, type CreateMessageOptions, type CreateModelPreferenceOptions, type CreateProjectOptions, type CreateSavedToolOptions, type CreateSelectPaymentWalletToolOptions, type CreateServerToolsFilterOptions, type CreateUserPreferenceOptions, type CreateVaultFolderOptions, type CreateVaultMemoryOptions, type CreateWalletPaymentToolOptions, type CryptoPriceClassification, type CryptoPricePreProcessorOptions, DEFAULT_CACHE_EXPIRATION_MS, DEFAULT_CHUNK_CACHE_SIZE, DEFAULT_CHUNK_OVERLAP, DEFAULT_CHUNK_SIZE, DEFAULT_DECAY_POLICY, DEFAULT_EXCLUDED_SERVER_TOOLS, DEFAULT_BACKUP_FOLDER as DEFAULT_ICLOUD_BACKUP_FOLDER, DEFAULT_MAX_CLASSIFIER_CALLS_PER_SWEEP, DEFAULT_MIN_CHUNK_SIZE, DEFAULT_PERSONALITY_SETTINGS, DEFAULT_PROFILE_FACETS, DEFAULT_PROFILE_FACT_TYPE_WEIGHTS, DEFAULT_PROFILE_PROOF_ALPHA, DEFAULT_PROFILE_TREND_MULTIPLIERS, DEFAULT_SERVER_TOOLS_MATCH_OPTIONS, DEFAULT_VAULT_CACHE_SIZE, DatabaseManager, type DatabaseManagerLogger, type DatabaseManagerOptions, type DecayCandidateRaw, type DecayClassifier, type DecayInput, type DecayPolicy, type DecaySweepResult, type DecaySweeper, type DecayVerdict, type DeckProps, type DisplayToolMigrations, type DurableAutoExtractorOptions, ENTITY_FANOUT, ENTITY_KINDS, type EmbeddedWalletSignerFn, type EmbeddingRepairOptions, type EmbeddingRepairResult, EncryptionKeyMissingError, type EncryptionKeyVersion, type EntityInput, type EntityKind, Entity as EntityModel, type EntityOperationsContext, ExcelProcessor, type ExtractFactsOptions, type ExtractOutcome, type ExtractedCandidate, type ExtractedEntity, type ExtractionCursorStore, type ExtractionFunnel, type ExtractionMessageSource, type ExtractionSourceMessage, type ExtractionSourceStatus, type ExtractionTimings, FILE_PLACEHOLDER_PREFIX, FILE_PLACEHOLDER_REGEX, type FactType, type FileMetadata, type FileProcessingReason, type FileProcessingStatus, type FileProcessor, type FileTypeQuery, type FileWithData, type FlushResult, type GetConversationsPageOptions, type GetMessagesPageOptions, type GraphTraversalOptions, type GroupProps, HARD_DELETE_WINDOW_MS, type ICloudAuthContextValue, ICloudAuthProvider, type ICloudAuthProviderProps, type ICloudExportResult, type ICloudImportResult, INFERENCE_ID_HEADER, INTERNAL_FLOW_MARKER, type IconProps, type ImageProps, type InjectionClassifierOptions, type InjectionReason, type InteractionType, type KnownTag, type LazyStoredConversation, type LineProps, type LlmDecayClassifierOptions, type LlmNeighborRefinerOptions, type LocalMemoryStoreOptions, type Logger, LoggerProvider, type LoggerProviderProps, MAX_HOPS, MEDIUM_TTL_MS, MEMORY_KINDS, MEMORY_LEVELS, type ManualFactType, type MediaDimensions, type MediaFilterOptions, type MediaMetadata, type MediaOperationsContext, type MediaRole, type MediaType, type MemoriesNeedingTopicExtraction, type MemoryContextItem, type MemoryContextLane, type MemoryContextOptions, type MemoryContextResult, type MemoryCounts, type MemoryCreate, type MemoryDecay, type MemoryDecaySweeperOptions, type EmbeddingOptions as MemoryEngineEmbeddingOptions, type MemoryEngineResult, type MemoryEngineSearchOptions, MemoryEntity as MemoryEntityModel, type MemoryExtractedEvent, MemoryKeyError, type MemoryKeyRing, type MemoryKind, type MemoryLevel, MemoryLevelError, type MemoryListOptions, type MemoryMaintenance, type MemoryMigrationOptions, type MemoryMigrationProgress, type MemoryMigrationResult, type MemoryMigrationSkip, type MemoryQuarantinedEvent, type MemoryRecallOptions, type MemoryRetainOptions, type MemoryStore, type MemorySubscribeOptions, type MemoryToVerify, type MemoryTopic, type MemoryTopicBacklog, type MemoryTopicMaintenance, type MemoryUpdate, type MemoryVaultSearchOptions, type MemoryVaultToolOptions, type MemoryVerification, type MessageChunk, type MessageFeedback, type MessageOrigin, type MessageSkeleton, type ModelLoadProgress, NEVER_TTL_MS, NODE_BUDGET, type NeighborRefiner, type NowSource, type OCRFile, type ObservationTrend, type ObservationTrendInput, type OperationExecutor, PAST_EVENT_GRACE_MS, PROFILE_DOC_VERSION, type ParsedServerToolsResponse, type PaymentWallet, type PdfExportOptions, type PdfExportProgress, type PdfExportStage, type PdfFile, PdfProcessor, type PendingInteraction, type PersonalitySettings, type PersonalitySliders, type PersonalityStyle, type PhoneCallPollingOptions, type PhotoIngestResult, type PhotoMediaRef, type PlatformStorage, type PortalLlmAuth, type PortalLlmFailure, type PortalLlmFailureReason, type PreprocessingOptions, type PreprocessingResult, type ProcessedFileResult, ProcessorRegistry, type ProfileConfigFingerprint, type ProfileDoc, type ProfileFacet, type ProfileFacetKey, type ProfileSalienceInput, type ProfileSection, type ProfileUpdate, type ProgressCallback, Project, type ProjectOperationsContext, type PromptPreProcessor, type PromptPreProcessorContext, type ProviderAuthState, type ProviderBackupState, ProviderStreamError, type PublishedPhotoMemory, type QuantizedEmbedding, type QuarantinedMemoryInfo, type QueueEncryptionContext, QueueManager, type QueueStatus, type QueuedOperation, type QueuedOperationType, R2_DEFAULT_TTL_MS, RECALL_MAX_LIMIT, RECALL_TOOL_NAME, type RankableVaultMemory, type RankedMemory, type RankedProfileCandidate, type RecallContext, type RecallDegradation, type RecallDiagnostics, type RecallEmptyReason, type RecallOptions, type RecallResult, type RecallTelemetryCallbacks, type RecallToolCallbacks, type RecallToolOptions, type RecallTruncation, type RecencyOptions, type RectProps, type ReflectOptions, type ReflectResult, type RemoteChatStoreOptions, type RemoteMemoryCandidateOptions, type RemoteMemoryDecodeFailure, RemoteMemoryError, type RemoteMemoryListOptions, type RemoteMemoryMetadataPage, type RemoteMemoryMetadataRecord, type RemoteMemoryPage, RemoteMemoryPartialCreateError, type RemoteMemoryPersistence, type RemoteMemoryPersistenceOptions, type RemoteMemoryPipeline, type RemoteMemoryPipelineOptions, type RemoteMemoryQueryOptions, type RemoteMemoryQueryPage, type RemoteMemoryReadFilters, type RemoteMemoryRecord, type RemoteMemoryRow, type RemoteMemoryStoreOptions, type RemoteMemoryTopic, type RemoteMemoryWorkKind, type RemoteMemoryWorkLease, type RemoteMemoryWorkPersistence, type RemoteTopicPersistence, type RequestEncryptionKeyOptions, RerankerUnavailableError, type ReservationReceipt, type ResumeStreamOptions, type ResumeStreamResult, type RetainAction, type RetainContext, type RetainOptions, type RetainResult, type RetainSource, SDK_SCHEMA_VERSION, SELECT_PAYMENT_WALLET_TOOL_NAME, SERVER_TOOL_DEPENDENCY_SETS, SHORT_TTL_MS, SLIDER_CONFIG, SLIDES_FILE_PATH, SLIDE_CANVAS_HEIGHT, SLIDE_CANVAS_WIDTH, STREAM_RESUMABLE_HEADER, SavedTool as SavedToolModel, type SavedToolOperationsContext, type SavedToolParameter, type ScoreBreakdown, type ScoreProfileSalienceOptions, type ScreenProps, type ScreenResult, type ScreenedCandidate, type SearchMessagesOptions, type SearchSource, type SelectPaymentWalletResult, type SelectServerToolsForPromptOptions, type SendMessageWithStorageArgs, type SendMessageWithStorageResult, type ServerTool, type ServerToolsFilter, type ServerToolsFilterFn, type ServerToolsFilterFunction, type ServerToolsOptions, type ServerToolsResponse, type SignMessageFn, type SignMessageOptions, type SlideProps, type StepFinishEvent, type StockPriceClassification, type StockPricePreProcessorOptions, type StorageOperationsContext, type StoredAppFile, type ChatCompletionUsage as StoredChatCompletionUsage, type StoredConversation, type StoredConversationMemory, type StoredEntity, type StoredFileWithContext, type StoredMedia, Media as StoredMediaModel, type StoredMessage, type StoredMessageWithSimilarity, type StoredModelPreference, ModelPreference as StoredModelPreferenceModel, type StoredProject, type StoredSavedTool, type StoredTopic, type StoredUserPreference, UserPreference as StoredUserPreferenceModel, type StoredVaultFolder, VaultFolder as StoredVaultFolderModel, type StoredVaultMemory, VaultMemory as StoredVaultMemoryModel, StreamExpiredError, type StreamMetaEvent, type StreamResumeHandle, type StreamSmoothingConfig, type SynthesizeProfileOptions, THEME_ATTRS, TOOL_RESULT_ORIGIN, TOPICS_EXTRACTION_VERSION, TOPIC_EXTRACTION_BATCH_SIZE, TOPIC_SALIENCE_WEIGHTS, TREND_RECENT_WINDOW_DAYS, TREND_STALE_WINDOW_DAYS, type TextChunk, TextProcessor, type TextProps, type ThemeAttr, type ToolCallArgumentsDeltaEvent, type ToolMatchOptions, type ToolMatchResult, type ToolSet, type TopicExtractOptions, type TopicExtractionBatchDiagnostics, type TopicExtractionInput, type TopicExtractionRunResult, type TopicSalience, type TopicSkipReason, type TopicSource, type TranscriptionResult, type TurnCompleteEvent, type TurnSkippedEvent, type UIInteractionContextValue, UIInteractionProvider, type UIInteractionProviderProps, type UncheckedReason, type UnverifiableReason, type UpdateMediaOptions, type UpdateModelPreferenceOptions, type UpdateProjectOptions, type UpdateSavedToolOptions, type UpdateUserPreferenceOptions, type UpdateVaultFolderOptions, type UpdateVaultMemoryOptions, type UseBackupOptions, type UseBackupResult, type UseChatStorageOptions, type UseChatStorageResult, type UseCreditsOptions, type UseCreditsResult, type UseEncryptionResult, type UseExportPdfResult, type UseFilesOptions, type UseFilesResult, type UseICloudBackupOptions, type UseICloudBackupResult, type UseModelsResult, type UseOCRResult, type UsePdfResult, type UsePhoneCallsOptions, type UsePhoneCallsResult, type UseProjectsOptions, type UseProjectsResult, type UseSettingsOptions, type UseSettingsResult, type UseSubscriptionOptions, type UseSubscriptionResult, type UseToolsOptions, type UseToolsResult, type UseVoiceOptions, type UseVoiceResult, type UseWalletBindingOptions, type UseWalletBindingResult, VAULT_SIZE_HOP_CAP, type VaultCandidateKey, type VaultChatActivity, type VaultChatBackend, type VaultChatBackendOptions, type VaultChatEvent, type VaultEmbeddingCache, type VaultEmbeddingExpectation, type VaultFolderOperationsContext, type VaultMemoryKind, type VaultMemoryOperationsContext, type VaultMemoryProjection, type VaultMemoryVisibility, type VaultMemoryWriter, type VaultSaveOperation, type VaultSearchResult, type VaultWriteAction, type VaultWriteInput, type VaultWriteOutcome, type VerificationSources, type VerifyMemoriesForPublishOptions, type VoiceRecording, WALLET_PAYMENT_TOOL_NAME, type WalletPaymentOutcome, type WalletPaymentPassenger, type WalletPaymentRequest, type WalletPaymentResult, WalletPoller, WatermelonChatStorageAdapter, type WatermelonChatStorageAdapterOptions, type WeatherClassification, type WeatherPreProcessorOptions, type WebSearchClassification, type WebSearchPreProcessorOptions, type WhisperModel, WordProcessor, type WriteFailureReason, ZipProcessor, type ZipProcessorOptions, addConversationMemoriesOp, appFileToStored, archiveVaultMemoryOp, assembleMemoryContext, attachFileContextToLastUserMessage, backfillMemoryEntityUserIdsOp, backfillMemoryTopicsOp, buildAttachedFilesText, capHopsForDensity, chatStorageMigrations, chatStorageSchema, chunkAndEmbedAllMessages, chunkAndEmbedMessage, chunkText, classifyCryptoPrice, classifyCryptoPriceBatch, classifyDecay, classifyInjectionCandidates, classifyObservationTrend, classifyStockPrice, classifyStockPriceBatch, classifyWeather, classifyWeatherBatch, classifyWebSearch, classifyWebSearchBatch, clearAllEncryptionKeys, clearAllEncryptionState, clearAllKeyPairs, clearConversationMemoriesOp, clearEncryptionKey, clearICloudAuth, clearKeyPair, clearLazyTitleCache, clearMemoryTopicsOverrideOp, clearModelsCache, clearNotionToken, clearServerToolsCache, consoleLogger, conversationMemoryToStored, cosineInt8, createAutoExtractor, createChunkVectorCache, createCryptoPricePreProcessor, createDecaySweeper, createDurableAutoExtractor, createGitHubTools, createLlmDecayClassifier, createLlmNeighborRefiner, createLocalMemoryStore, createMediaBatchOp, createMediaOp, createMemoryEngineTool, createMemoryVaultSearchTool, createMemoryVaultTool, createMessageSourceResolver, createPlatformCursorStore, createProjectOp, createRecallTool, createRemoteChatStore, createRemoteMemoryPersistence, createRemoteMemoryPipeline, createRemoteMemoryStore, createSavedToolOp, createSelectPaymentWalletTool, createServerToolsFilter, createStockPricePreProcessor, createVaultChatBackend, createVaultEmbeddingCache, createVaultFolderOp, createVaultMemoriesBatchOp, createVaultMemoryOp, createWalletPaymentTool, createWeatherPreProcessor, createWebSearchPreProcessor, decodeChunkVector, decryptConversationTitle, decryptData, decryptDataBatch, decryptDataBytes, decryptDataBytesFromBytes, decryptDataWithKey, decryptMessageEmbeddingFields, defaultServerToolsFilter, deleteAllAppFilesOp, deleteAllVaultMemoriesForUserOp, deleteAppFileOp, deleteEncryptedFile, deleteMediaByConversationOp, deleteMediaByMessageOp, deleteMediaOp, deleteMessageOp, deleteProjectOp, deleteSavedToolOp, deleteVaultFolderOp, deleteVaultMemoryOp, dequantizeEmbedding, deriveKeyFromSignatureBytes, deriveMemoryKeyRing, eagerEmbedContent, embedAllMessages, embedMessage, encodeChunkVector, encryptData, encryptDataBatch, encryptDataBytes, encryptDataWithKey, encryptToolCallEventsOp, ensureDefaultFoldersOp, expandToolSetsAdditive, exportElementToPdf, exportMarkdownToPdf, exportPublicKey, extractAndLinkEntitiesForMemoriesOp, extractAndRetain, extractEntitiesForMemories, extractFacts, extractFileIds, extractMCPImageUrls, extractReservationReceipts, fileExists, findById, findMatchingTools, findParentOfId, formatFileProcessingNotes, generateConversationId, generateEmbedding, generateEmbeddings, generateMediaId, generateProjectId, getAIGeneratedMediaOp, getAllSavedToolsOp, getAllVaultFoldersOp, getAllVaultMemoriesOp, getAllVaultMemoryContentsOp, getAndClearNotionPendingMessage, getAndClearNotionReturnUrl, getAppFileMapOp, getAppFileOp, getAppFilesOp, getAudioOp, getCachedServerTools, getConversationMemoriesOp, getConversationsByProjectLazyOp, getConversationsByProjectOp, getConversationsLazyOp, getConversationsPageOp, getDecayCandidatesRawOp, getDocumentsOp, getEncryptionKey, getEntitiesByMemoryIdsOp, getId, getImagesOp, getLogger, getMediaByConversationOp, getMediaByIdOp, getMediaByIdsOp, getMediaByMessageOp, getMediaByModelOp, getMediaByRoleOp, getMediaBySourceUrlOp, getMediaByTypeOp, getMediaCountOp, getMediaCountsByTypeOp, getMediaOp, getMediaTypeFromMime, getMemoriesByEntityNamesOp, getMemoriesNeedingTopicExtractionOp, getNotionAccessToken, getNotionMCPUrl, getNumberAttr, getProjectConversationCountOp, getProjectConversationsOp, getProjectOp, getProjectsOp, getRecentMediaOp, getSavedToolByIdOp, getServerTools, getStringAttr, getSupportedFileTypes, getToolsChecksum, getUnfiledVaultMemoriesOp, getUserUploadedMediaOp, getValidNotionToken, getVaultCandidateKeysOp, getVaultEmbeddingsByIdsOp, getVaultFolderMemoryCountOp, getVaultMemoriesByIdsOp, getVaultMemoryOp, getVaultRankingProjectionsOp, getVideosOp, handleNotionCallback, hardDeleteDecayedOp, hardDeleteMediaOp, hasEncryptionKey, hasICloudCredentials, hasKeyPair, hasNotionCredentials, ingestPublishedPhotoMemoriesOp, injectionSignatureCatalog, insertAfterId, insertChild, isAnumaTag, isAttachedFilesText, isDegradedTopicSkip, isEncrypted, isHtmlTag, isNotionCallback, isOPFSSupported, isR2UrlExpired, isRerankerAvailable, isSupportedFile, isSupportedMediaType, linkMemoryEntitiesOp, localChatBackend, maskScopedEmbeddingCache, mediaToStored, memoryCipher, migrateChatsToRemote, migrateDisplayResult, migrateMemoriesToRemote, migrateNotionClientRegistration, migrateNotionToken, moveMemoriesToFolderOp, noopLogger, onKeyAvailable, parseJsx, parseMedia, preEmbedVaultMemories, preprocessFiles, previewToolSelection, primaryTopic, projectToStored, putAppFileOp, quantizeEmbedding, queueManager, rankProfileCandidates, readEncryptedFile, recall, reencryptMemoryField, reflect, refreshEncryptionKeyIfMatches, refreshNotionToken, relinkMemoryTopicsOp, relinkMisclassifiedVideosOp, removeById, renderAnumaJsx, renderAnumaTree, renderElementToCanvas, replaceById, replaceMemoryEntitiesGuardedOp, requestEncryptionKey, requestKeyPair, resolveFilePlaceholders, resolveThemeColor, restoreVaultMemoryOp, resumeStream, retain, revokeNotionAccess, savedToolToStored, scoreProfileSalience, screenCandidatesForInjection, sdkMigrations, sdkModelClasses, sdkSchema, sealLegacyMessageEmbeddingsOp, searchChunksOp, searchMediaOp, searchMessagesOp, searchVaultMemories, seedEncryptionKeys, selectServerToolsForPrompt, serializeJsx, setLogger, setMemoryEntitiesOp, setMemoryVisibilityOp, settingsStorageSchema, shouldChunkMessage, shouldRecallMemory, shouldRefreshTools, stampTopicsExtractedAtOp, startNotionAuth, storeNotionPendingMessage, storeNotionReturnUrl, streamCancelPath, streamReplayPath, stripLegacyChunkTextOp, summarizeObservationTrends, supersedeVaultMemoryOp, synthesizeProfile, topicWeight, traverseGraphLane, ttlForType, updateAttrs, updateConversationProjectOp, updateMediaMessageIdBatchOp, updateMediaOp, updateMessageFeedbackOp, updateProjectNameOp, updateProjectOp, updateSavedToolOp, updateVaultFolderContextOp, updateVaultFolderOp, updateVaultMemoryEmbeddingOp, updateVaultMemoryOp, useAnumaTheme, useBackup, useBackupAuth, useChat, useChatStorage, useCredits, useDatabaseManager, useEncryption, useExportPdf, useFiles, useICloudAuth, useICloudBackup, useModels, useOCR, usePdf, usePhoneCalls, useProjects, useSettings, useSubscription, useTools, useUIInteraction, useVoice, useWalletBinding, userPreferencesStorageSchema, vaultChatBackend, verifyMemoriesForPublish, walk, webPlatformStorage, withActiveToolSetServerTools, withInternalFlowMarker, writeEncryptedFile };