@anuma/sdk 10.3.1 → 10.4.1

package/dist/react/index.d.ts

@@ -1,4 +1,4 @@
-import { Database, Model, Collection } from '@nozbe/watermelondb';
+import { Model, Database, 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';
@@ -3190,1059 +3190,861 @@ interface WebSearchPreProcessorOptions {
  */
 declare function createWebSearchPreProcessor(options?: WebSearchPreProcessorOptions): PromptPreProcessor;
 
+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;
+}
+
 /**
- * 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)
+ * A canonical entity (person, place, thing) extracted from the user's
+ * conversations. Many-to-many with vault memories via {@link MemoryEntity}.
  *
- * 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.
- */
-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".
+ * 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 EncryptionKeyMissingError extends Error {
-    readonly address: string;
-    readonly version: EncryptionKeyVersion;
-    constructor(address: string, version: EncryptionKeyVersion);
+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;
 }
 /**
- * Options for {@link requestEncryptionKey}.
+ * Join row: a memory references an entity (and vice versa). Multiple
+ * rows per memory (one per entity) and per entity (one per memory).
  */
-interface RequestEncryptionKeyOptions {
+declare class MemoryEntity extends Model {
+    static table: string;
+    memoryId: string;
+    entityId: string;
     /**
-     * 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.
+     * 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.
      */
-    force?: boolean;
+    userId: string | null;
+    createdAt: Date;
 }
+
 /**
- * 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
+ * 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 function onKeyAvailable(address: string, callback: () => void): () => void;
+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;
+}
 /**
- * Clears the encryption key for a wallet address from memory
- * @param address - The wallet address
+ * 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.
+ *
+ * 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
  */
-declare function clearEncryptionKey(address: string): void;
+type TopicSource = "user" | "auto";
 /**
- * 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.
- *
- * 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.
- *
- * @example
- * ```tsx
- * import { clearAllEncryptionState } from "@anuma/sdk/react";
- *
- * async function handleLogout() {
- *   clearAllEncryptionState();
- *   await privy.logout();
- * }
- * ```
+ * 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
  */
-declare function clearAllEncryptionState(): void;
+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;
+}
 /**
- * Clears all encryption keys from memory.
- *
- * @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).
+ * Fixed weight per salience level the topic extractor assigns.
+ * @public
  */
-declare function clearAllEncryptionKeys(): void;
+declare const TOPIC_SALIENCE_WEIGHTS: {
+    readonly primary: 1;
+    readonly secondary: 0.6;
+    readonly mention: 0.3;
+};
+/** @public */
+type TopicSalience = keyof typeof TOPIC_SALIENCE_WEIGHTS;
 /**
- * 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.
- *
- * 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
+ * A topic's weight: 1 when it is user-set or carries no weight.
+ * @public
  */
-declare function deriveKeyFromSignatureBytes(signature: Uint8Array): Promise<string>;
+declare function topicWeight(topic: StoredTopic): number;
 /**
- * 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
+ * The first topic with the highest weight, or null when there are none.
+ * @public
  */
-declare function getEncryptionKey(address: string, version?: EncryptionKeyVersion): Promise<CryptoKey>;
+declare function primaryTopic(topics: readonly StoredTopic[] | null | undefined): StoredTopic | null;
+/** @public */
+interface CreateEntityOptions {
+    canonicalName: string;
+    kind?: EntityKind | (string & {});
+}
+
 /**
- * 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";
+ * 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.
  *
- * // First, ensure encryption key exists
- * await requestEncryptionKey(walletAddress);
+ * `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.
  *
- * // Then encrypt data
- * const encrypted = await encryptData("my secret data", walletAddress);
- * localStorage.setItem("mySecret", encrypted);
- * ```
+ * `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.
  *
- * @category Encryption
+ * @deprecated App code: use `MemoryStore.addTopics` (`createLocalMemoryStore`).
  */
-declare function encryptData(plaintext: string | Uint8Array, address: string): Promise<string>;
+declare function linkMemoryEntitiesOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>, options?: {
+    unlessTopicsUserManaged?: boolean;
+    topicsSource?: TopicSource;
+}): Promise<StoredEntity[]>;
 /**
- * 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).
+ * 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).
  *
- * @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
+ * 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.
+ *
+ * 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 encryptDataBytes(plaintext: Uint8Array, address: string): Promise<Uint8Array>;
+declare function replaceMemoryEntitiesGuardedOp(ctx: EntityOperationsContext, memoryId: string, entityInputs: ReadonlyArray<EntityInput>): Promise<StoredEntity[] | null>;
 /**
- * Decrypts data using AES-GCM with the stored encryption key.
+ * Backfill `memory_entity.user_id` from the parent vault row's user_id.
+ * Idempotent — only touches rows where user_id is null.
  *
- * 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.
+ * 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.
  *
- * @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
+ * 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.
  *
- * @example
- * ```tsx
- * import { decryptData, requestEncryptionKey } from "@anuma/sdk/react";
+ * @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.
  *
- * // First, ensure encryption key exists
- * await requestEncryptionKey(walletAddress);
+ * 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.
  *
- * // Then decrypt data
- * const encrypted = localStorage.getItem("mySecret");
- * if (encrypted) {
- *   const decrypted = await decryptData(encrypted, walletAddress);
- *   console.log("Decrypted:", decrypted);
- * }
- * ```
+ * Names are normalized (lowercased, trimmed). Empty input returns an
+ * empty map. Names that don't exist as entities contribute nothing.
  *
- * @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.
+ * 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.
  *
- * @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
+ * @deprecated App code: use `MemoryStore.memoriesByTopics` (`createLocalMemoryStore`).
  */
-declare function decryptDataBytesFromBytes(encrypted: Uint8Array, address: string, version?: EncryptionKeyVersion): Promise<Uint8Array>;
+declare function getMemoriesByEntityNamesOp(ctx: EntityOperationsContext, entityNames: readonly string[]): Promise<Map<string, Set<string>>>;
 /**
- * Checks if an encryption key exists in memory for the given wallet address.
+ * 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.
  *
- * @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.
+ * Empty input returns an empty map. Memory IDs with no links contribute
+ * nothing (they simply don't appear as keys).
  *
- * 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).
+ * 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.
  *
- * Existing versions are preserved when the corresponding argument is omitted.
- * Pass an explicit empty merge is not supported; omit the field to leave it.
+ * @public
  *
- * Each provided key must be 64 hex characters (32-byte AES key).
+ * @deprecated App code: use `MemoryStore.topicsByMemories` (`createLocalMemoryStore`).
  */
-declare function seedEncryptionKeys(address: string, keys: {
-    legacy?: string;
-    current?: string;
-}): void;
+declare function getEntitiesByMemoryIdsOp(ctx: EntityOperationsContext, memoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
+
 /**
- * Encrypts data using a pre-fetched CryptoKey.
- * Use this for batch operations to avoid repeated key lookups.
+ * 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)
  *
- * @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
+ * 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.
  */
-declare function encryptDataWithKey(plaintext: string | Uint8Array, key: CryptoKey): Promise<string>;
+type EncryptionKeyVersion = "v2" | "v3";
 /**
- * Decrypts data using a pre-fetched CryptoKey.
- * Use this for batch operations to avoid repeated key lookups.
- *
- * @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
+ * 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 function decryptDataWithKey(encryptedHex: string, key: CryptoKey): Promise<string>;
+declare class EncryptionKeyMissingError extends Error {
+    readonly address: string;
+    readonly version: EncryptionKeyVersion;
+    constructor(address: string, version: EncryptionKeyVersion);
+}
 /**
- * Batch encrypt multiple values efficiently with a single key lookup.
- * Much faster than calling encryptData for each value individually.
- *
- * @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
- *
- * @example
- * ```tsx
- * const encrypted = await encryptDataBatch(
- *   ["secret1", "secret2", "secret3"],
- *   walletAddress
- * );
- * ```
- *
- * @category Encryption
+ * Options for {@link requestEncryptionKey}.
  */
-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.
- *
- * @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
- */
-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;
+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;
 }
 /**
- * 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}.
+ * 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 SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
+declare function onKeyAvailable(address: string, callback: () => void): () => void;
 /**
- * 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.
+ * Clears the encryption key for a wallet address from memory
+ * @param address - The wallet address
  */
-type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
+declare function clearEncryptionKey(address: string): void;
 /**
- * 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.
+ * Clears all encryption-related state from memory and any derived persistence.
  *
- * 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.
+ * 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.
  *
- * 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).
+ * 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.
  *
- * @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).
+ * @example
+ * ```tsx
+ * import { clearAllEncryptionState } from "@anuma/sdk/react";
+ *
+ * async function handleLogout() {
+ *   clearAllEncryptionState();
+ *   await privy.logout();
+ * }
+ * ```
  */
-declare function requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn, options?: RequestEncryptionKeyOptions): Promise<boolean>;
+declare function clearAllEncryptionState(): void;
 /**
- * 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.
+ * Clears all encryption keys from memory.
  *
- * @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.
+ * @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 function refreshEncryptionKeyIfMatches(walletAddress: string, probeCiphertext: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<boolean>;
+declare function clearAllEncryptionKeys(): void;
 /**
- * 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.
+ * Derives the bytes-native AES key from a raw signature.
  *
- * 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.
+ * 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.
  *
- * @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
+ * 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
  */
-declare function hasKeyPair(address: string): boolean;
+declare function deriveKeyFromSignatureBytes(signature: Uint8Array): Promise<string>;
 /**
- * Clears the key pair for a wallet address from memory and localStorage
+ * 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 function clearKeyPair(address: string): void;
+declare function getEncryptionKey(address: string, version?: EncryptionKeyVersion): Promise<CryptoKey>;
 /**
- * Clears all key pairs from memory and any persisted entries in localStorage.
+ * Encrypts data using AES-GCM with the stored encryption key.
  *
- * 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 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.
  *
- * 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.
+ * @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
  *
- * ## How it works
+ * @example
+ * ```tsx
+ * import { encryptData, requestEncryptionKey } from "@anuma/sdk/react";
  *
- * 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
+ * // First, ensure encryption key exists
+ * await requestEncryptionKey(walletAddress);
  *
- * ## Security Features
+ * // Then encrypt data
+ * const encrypted = await encryptData("my secret data", walletAddress);
+ * localStorage.setItem("mySecret", encrypted);
+ * ```
  *
- * - **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
+ * @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).
  *
- * ## Embedded Wallet Support
+ * @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.
  *
- * 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.
+ * 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.
  *
- * @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
+ * @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
  *
  * @example
  * ```tsx
- * import { usePrivy, useWallets } from "@privy-io/react-auth";
- * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
+ * import { decryptData, requestEncryptionKey } from "@anuma/sdk/react";
  *
- * function SecureComponent() {
- *   const { user, signMessage } = usePrivy();
- *   const { wallets } = useWallets();
- *   const embeddedWallet = wallets.find(w => w.walletClientType === 'privy');
+ * // First, ensure encryption key exists
+ * await requestEncryptionKey(walletAddress);
  *
- *   // 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]);
+ * // Then decrypt data
+ * const encrypted = localStorage.getItem("mySecret");
+ * if (encrypted) {
+ *   const decrypted = await decryptData(encrypted, walletAddress);
+ *   console.log("Decrypted:", decrypted);
+ * }
+ * ```
  *
- *   const { requestEncryptionKey } = useEncryption(signMessage, embeddedSigner);
+ * @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.
  *
- *   // 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 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.
  *
- *   // Encrypt data
- *   const saveSecret = async (text: string) => {
- *     const encrypted = await encryptData(text, user.wallet.address);
- *     localStorage.setItem("mySecret", encrypted);
- *   };
+ * @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.
  *
- *   // Decrypt data
- *   const loadSecret = async () => {
- *     const encrypted = localStorage.getItem("mySecret");
- *     if (encrypted) {
- *       const decrypted = await decryptData(encrypted, user.wallet.address);
- *       console.log(decrypted);
- *     }
- *   };
+ * 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).
  *
- *   return (
- *     <div>
- *       <button onClick={() => saveSecret("my secret data")}>Encrypt & Save</button>
- *       <button onClick={loadSecret}>Load & Decrypt</button>
- *     </div>
- *   );
- * }
- * ```
+ * Existing versions are preserved when the corresponding argument is omitted.
+ * Pass an explicit empty merge is not supported; omit the field to leave it.
  *
- * @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";
+ * 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.
  *
- * function SecureComponent() {
- *   const { user, signMessage } = usePrivy();
- *   const { requestEncryptionKey } = useEncryption(signMessage);
+ * @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.
  *
- *   // 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]);
- * }
- * ```
+ * @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.
+ *
+ * @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
  *
  * @example
  * ```tsx
- * // ECDH key pair generation for end-to-end encryption
- * import { usePrivy } from "@privy-io/react-auth";
- * import { useEncryption } from "@anuma/sdk/react";
+ * const encrypted = await encryptDataBatch(
+ *   ["secret1", "secret2", "secret3"],
+ *   walletAddress
+ * );
+ * ```
  *
- * function E2EEComponent() {
- *   const { signMessage } = usePrivy();
- *   const { requestKeyPair, exportPublicKey } = useEncryption(signMessage);
+ * @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.
  *
- *   const setupEncryption = async (walletAddress: string) => {
- *     // Generate deterministic ECDH key pair from wallet signature
- *     await requestKeyPair(walletAddress);
+ * @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
  *
- *     // Export public key to share with others
- *     const publicKey = await exportPublicKey(walletAddress);
- *     console.log("Share this public key:", publicKey);
- *   };
- * }
+ * @example
+ * ```tsx
+ * const decrypted = await decryptDataBatch(
+ *   [encrypted1, encrypted2, encrypted3],
+ *   walletAddress
+ * );
  * ```
- *
- * @category Hooks
- */
-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;
+ *
+ * @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;
 }
-
 /**
- * A canonical entity (person, place, thing) extracted from the user's
- * conversations. Many-to-many with vault memories via {@link MemoryEntity}.
+ * Type for the signMessage function that client must provide.
+ * This is typically from Privy's useSignMessage hook.
  *
- * 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.
+ * 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 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;
-}
+type SignMessageFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
- * Join row: a memory references an entity (and vice versa). Multiple
- * rows per memory (one per entity) and per entity (one per memory).
+ * 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 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;
-}
-
+type EmbeddedWalletSignerFn = (message: string, options?: SignMessageOptions) => Promise<string>;
 /**
- * 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
+ * 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 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 requestEncryptionKey(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn, options?: RequestEncryptionKeyOptions): Promise<boolean>;
 /**
- * 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.
+ * 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.
  *
- * 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
+ * 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.
  */
-type TopicSource = "user" | "auto";
+declare function refreshEncryptionKeyIfMatches(walletAddress: string, probeCiphertext: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<boolean>;
 /**
- * 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
+ * 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.
+ *
+ * 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 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
  */
-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 requestKeyPair(walletAddress: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<void>;
 /**
- * Fixed weight per salience level the topic extractor assigns.
- * @public
+ * 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 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 exportPublicKey(address: string, signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): Promise<string>;
 /**
- * A topic's weight: 1 when it is user-set or carries no weight.
- * @public
+ * 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 topicWeight(topic: StoredTopic): number;
+declare function hasKeyPair(address: string): boolean;
 /**
- * The first topic with the highest weight, or null when there are none.
- * @public
+ * Clears the key pair for a wallet address from memory and localStorage
+ * @param address - The wallet address
  */
-declare function primaryTopic(topics: readonly StoredTopic[] | null | undefined): StoredTopic | null;
-/** @public */
-interface CreateEntityOptions {
-    canonicalName: string;
-    kind?: EntityKind | (string & {});
-}
-
+declare function clearKeyPair(address: string): void;
 /**
- * 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
+ * Clears all key pairs from memory and any persisted entries in localStorage.
+ *
+ * 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.
  */
-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>;
+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;
 }
 /**
- * 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.
+ * Hook that provides encryption key management for securing local data.
  *
- * `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 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
  *
- * `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.
+ * 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.
  *
- * @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).
+ * @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
  *
- * 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.
+ * @example
+ * ```tsx
+ * import { usePrivy, useWallets } from "@privy-io/react-auth";
+ * import { useEncryption, encryptData, decryptData } from "@anuma/sdk/react";
  *
- * 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.
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { wallets } = useWallets();
+ *   const embeddedWallet = wallets.find(w => w.walletClientType === 'privy');
  *
- * 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.
+ *   // 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]);
  *
- * 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.
+ *   const { requestEncryptionKey } = useEncryption(signMessage, embeddedSigner);
  *
- * @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.
+ *   // 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]);
  *
- * 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.
+ *   // Encrypt data
+ *   const saveSecret = async (text: string) => {
+ *     const encrypted = await encryptData(text, user.wallet.address);
+ *     localStorage.setItem("mySecret", encrypted);
+ *   };
  *
- * Names are normalized (lowercased, trimmed). Empty input returns an
- * empty map. Names that don't exist as entities contribute nothing.
+ *   // Decrypt data
+ *   const loadSecret = async () => {
+ *     const encrypted = localStorage.getItem("mySecret");
+ *     if (encrypted) {
+ *       const decrypted = await decryptData(encrypted, user.wallet.address);
+ *       console.log(decrypted);
+ *     }
+ *   };
  *
- * 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.
+ *   return (
+ *     <div>
+ *       <button onClick={() => saveSecret("my secret data")}>Encrypt & Save</button>
+ *       <button onClick={loadSecret}>Load & Decrypt</button>
+ *     </div>
+ *   );
+ * }
+ * ```
  *
- * @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.
+ * @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";
  *
- * Empty input returns an empty map. Memory IDs with no links contribute
- * nothing (they simply don't appear as keys).
+ * function SecureComponent() {
+ *   const { user, signMessage } = usePrivy();
+ *   const { requestEncryptionKey } = useEncryption(signMessage);
  *
- * 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.
+ *   // 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]);
+ * }
+ * ```
  *
- * @public
+ * @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.topicsByMemories` (`createLocalMemoryStore`).
+ * function E2EEComponent() {
+ *   const { signMessage } = usePrivy();
+ *   const { requestKeyPair, exportPublicKey } = useEncryption(signMessage);
+ *
+ *   const setupEncryption = async (walletAddress: string) => {
+ *     // Generate deterministic ECDH key pair from wallet signature
+ *     await requestKeyPair(walletAddress);
+ *
+ *     // Export public key to share with others
+ *     const publicKey = await exportPublicKey(walletAddress);
+ *     console.log("Share this public key:", publicKey);
+ *   };
+ * }
+ * ```
+ *
+ * @category Hooks
  */
-declare function getEntitiesByMemoryIdsOp(ctx: EntityOperationsContext, memoryIds: readonly string[]): Promise<Map<string, Set<string>>>;
+declare function useEncryption(signMessage: SignMessageFn, embeddedWalletSigner?: EmbeddedWalletSignerFn): UseEncryptionResult;
 
 /**
  * Checks if a string value is encrypted (has the enc:v2: or enc:v3: prefix with valid hex payload).
@@ -8507,6 +8309,14 @@ interface FileMetadata {
      */
     sourceUrl?: string;
 }
+/** Points a message's local file (`FileMetadata.id` or a `fileIds` media id) at its encrypted copy in vault, so any device can fetch it. */
+interface VaultAttachmentRef {
+    attachmentId: string;
+    fileId: string;
+    name: string;
+    type: string;
+    size: number;
+}
 interface ChatCompletionUsage {
     promptTokens?: number;
     completionTokens?: number;
@@ -8610,6 +8420,7 @@ interface StoredMessage {
     files?: FileMetadata[];
     /** Array of media_id references for direct lookup in media table */
     fileIds?: string[];
+    vaultAttachments?: VaultAttachmentRef[];
     createdAt: Date;
     updatedAt: Date;
     vector?: number[];
@@ -8786,6 +8597,7 @@ interface CreateMessageOptions {
     files?: FileMetadata[];
     /** Array of media_id references for direct lookup in media table */
     fileIds?: string[];
+    vaultAttachments?: VaultAttachmentRef[];
     usage?: ChatCompletionUsage;
     sources?: SearchSource[];
     responseDuration?: number;
@@ -9336,29 +9148,336 @@ interface BaseSendMessageWithStorageArgs {
      */
     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[]>;
-    /**
-     * 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 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>;
+}
+declare function generateConversationId(): string;
+
+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;
 }
-declare function generateConversationId(): string;
+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>;
+
+/**
+ * AES-GCM keys derived from one wallet signature over `SIGN_MESSAGE`.
+ * @public
+ */
+interface MemoryKeyRing {
+    keyId: string;
+    v3: CryptoKey;
+    v2: CryptoKey;
+}
+/**
+ * Thrown when no supplied key decrypts a field.
+ * @public
+ */
+declare class MemoryKeyError extends Error {
+    constructor(message: string);
+}
+/**
+ * Derive the v3 and legacy v2 memory keys from a hex wallet signature.
+ * @public
+ */
+declare function deriveMemoryKeyRing(signatureHex: string): Promise<MemoryKeyRing>;
+/**
+ * Encrypt and decrypt callbacks for `createRemoteMemoryPersistence` under the canonical key.
+ * @public
+ */
+declare function memoryCipher(canonical: MemoryKeyRing): {
+    encrypt: (plaintext: string) => Promise<string>;
+    decrypt: (ciphertext: string) => Promise<string>;
+};
+/**
+ * Re-encrypt a local field under the canonical key.
+ * @throws MemoryKeyError when no key decrypts the field.
+ * @public
+ */
+declare function reencryptMemoryField(value: string, canonical: MemoryKeyRing, fallbacks?: readonly MemoryKeyRing[]): Promise<string>;
+
+/** The largest file vault stores, after the encryption frame is added. */
+declare const maxVaultAttachmentBytes: number;
+/** Device-side store for decrypted attachment bytes, keyed by vault attachment id. */
+interface VaultAttachmentCache {
+    get(attachmentId: string): Promise<Uint8Array | null>;
+    set(attachmentId: string, bytes: Uint8Array): Promise<void>;
+    delete(attachmentId: string): Promise<void>;
+}
+interface VaultAttachmentOwner {
+    kind: "message" | "summary";
+    id: string;
+}
+interface VaultAttachmentsOptions {
+    store: ChatStore;
+    keyRing: MemoryKeyRing;
+    cache?: VaultAttachmentCache;
+    fetch?: typeof globalThis.fetch;
+    retries?: number;
+    retryDelayMs?: number;
+    now?: () => number;
+}
+interface VaultAttachmentUploadOptions {
+    signal?: AbortSignal;
+    /** Runs before any bytes leave the device, again for each new reservation. */
+    onReserved?: (attachmentId: string) => void | Promise<void>;
+}
+/** Encrypted chat attachments in vault: upload, bind to a message, read back on any device, delete. */
+interface VaultAttachments {
+    /** Encrypts and uploads `bytes`; the attachment stays pending until `commit`, and vault drops it after 24h. */
+    upload(bytes: Uint8Array, options?: VaultAttachmentUploadOptions): Promise<string>;
+    /** Binds an uploaded attachment to a message or summary that vault already holds. */
+    commit(attachmentId: string, owner: VaultAttachmentOwner, signal?: AbortSignal): Promise<ChatAttachment>;
+    /** The decrypted bytes, or null when the attachment is gone or not yet committed. */
+    read(attachmentId: string, signal?: AbortSignal): Promise<Uint8Array | null>;
+    delete(attachmentId: string, signal?: AbortSignal): Promise<void>;
+}
+/** Creates the attachment client for one account and key; bytes are AES-GCM sealed with the ring's v3 key before upload. */
+declare function createVaultAttachments(options: VaultAttachmentsOptions): VaultAttachments;
+/** Where a migration run keeps the reservation it is working on, so a rerun resumes it instead of uploading again. */
+interface VaultAttachmentJournal {
+    get(key: string): Promise<string | null>;
+    set(key: string, attachmentId: string | null): Promise<void>;
+}
+interface LocalMessageAttachment {
+    /** `FileMetadata.id` or the media id listed in `fileIds`. */
+    fileId: string;
+    name: string;
+    type: string;
+    read(): Promise<Uint8Array | null>;
+}
+interface MessageAttachmentMigrationOptions {
+    store: ChatStore;
+    attachments: VaultAttachments;
+    journal: VaultAttachmentJournal;
+    /** The message's vault id (`StoredMessage.uniqueId`); vault must already hold it. */
+    messageId: string;
+    files: readonly LocalMessageAttachment[];
+    now?: () => number;
+    signal?: AbortSignal;
+}
+interface MessageAttachmentMigrationResult {
+    refs: VaultAttachmentRef[];
+    uploaded: number;
+    missing: string[];
+    oversized: string[];
+    /** File ids another run may still be uploading; rerun after 16 minutes. */
+    deferred: string[];
+}
+/** The vault attachment refs a message record carries; malformed entries are left out. */
+declare function vaultAttachmentRefs(record: Pick<ChatRecord, "data">): VaultAttachmentRef[];
+/** Copies a message's local files into vault and records their ids on the message; safe to rerun after a crash without uploading a file twice. */
+declare function migrateMessageAttachments(options: MessageAttachmentMigrationOptions): Promise<MessageAttachmentMigrationResult>;
 
 /** Durable home for each account's sealed chat cache; `set(account, null)` deletes that account's entry. */
 interface ChatCacheStorage {
@@ -11820,42 +11939,6 @@ interface LocalMemoryStoreOptions {
  */
 declare function createLocalMemoryStore(options: LocalMemoryStoreOptions): MemoryStore;
 
-/**
- * AES-GCM keys derived from one wallet signature over `SIGN_MESSAGE`.
- * @public
- */
-interface MemoryKeyRing {
-    keyId: string;
-    v3: CryptoKey;
-    v2: CryptoKey;
-}
-/**
- * Thrown when no supplied key decrypts a field.
- * @public
- */
-declare class MemoryKeyError extends Error {
-    constructor(message: string);
-}
-/**
- * Derive the v3 and legacy v2 memory keys from a hex wallet signature.
- * @public
- */
-declare function deriveMemoryKeyRing(signatureHex: string): Promise<MemoryKeyRing>;
-/**
- * Encrypt and decrypt callbacks for `createRemoteMemoryPersistence` under the canonical key.
- * @public
- */
-declare function memoryCipher(canonical: MemoryKeyRing): {
-    encrypt: (plaintext: string) => Promise<string>;
-    decrypt: (ciphertext: string) => Promise<string>;
-};
-/**
- * Re-encrypt a local field under the canonical key.
- * @throws MemoryKeyError when no key decrypts the field.
- * @public
- */
-declare function reencryptMemoryField(value: string, canonical: MemoryKeyRing, fallbacks?: readonly MemoryKeyRing[]): Promise<string>;
-
 /** @public */
 interface RemoteMemoryTopic {
     name: string;
@@ -16212,4 +16295,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 ChatBackend, type ChatBackendFactory, type ChatBackendSigner, type ChatCacheStorage, 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 };
+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 ChatCacheStorage, 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 LocalMessageAttachment, 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 MessageAttachmentMigrationOptions, type MessageAttachmentMigrationResult, 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 VaultAttachmentCache, type VaultAttachmentJournal, type VaultAttachmentOwner, type VaultAttachmentRef, type VaultAttachmentUploadOptions, type VaultAttachments, type VaultAttachmentsOptions, 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, createVaultAttachments, 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, maxVaultAttachmentBytes, mediaToStored, memoryCipher, migrateChatsToRemote, migrateDisplayResult, migrateMemoriesToRemote, migrateMessageAttachments, 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, vaultAttachmentRefs, vaultChatBackend, verifyMemoriesForPublish, walk, webPlatformStorage, withActiveToolSetServerTools, withInternalFlowMarker, writeEncryptedFile };