@anuma/sdk 6.35.0 → 6.36.0

package/dist/expo/index.mjs

@@ -2358,14 +2358,14 @@ async function updateMessageEmbeddingOp(ctx, uniqueId, vector, embeddingModel) {
   });
   return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
-async function updateMessageChunksOp(ctx, uniqueId, chunks, embeddingModel) {
+async function updateMessageChunksOp(ctx, uniqueId, chunks2, embeddingModel) {
   let message;
   try {
     message = await ctx.messagesCollection.find(uniqueId);
   } catch {
     return null;
   }
-  const storedChunks = chunks.map(({ text: _text, ...rest }) => rest);
+  const storedChunks = chunks2.map(({ text: _text, ...rest }) => rest);
   await ctx.database.write(async () => {
     await message.update((msg) => {
       msg._setRaw("chunks", JSON.stringify(storedChunks));
@@ -2409,12 +2409,12 @@ async function stripLegacyChunkTextOp(ctx) {
       const messages = await ctx.messagesCollection.query(Q.where("id", Q.oneOf(changedIds))).fetch();
       const updates = messages.flatMap((message) => {
         const raw = message._raw;
-        const chunks = chunksWithoutText(raw.chunks);
-        if (!chunks) return [];
+        const chunks2 = chunksWithoutText(raw.chunks);
+        if (!chunks2) return [];
         const updatedAt = raw.updated_at;
         return [
           message.prepareUpdate((msg) => {
-            msg._setRaw("chunks", JSON.stringify(chunks));
+            msg._setRaw("chunks", JSON.stringify(chunks2));
             msg._setRaw("updated_at", updatedAt);
           })
         ];
@@ -2575,15 +2575,15 @@ async function searchChunksOp(ctx, queryVector, options) {
       }
       continue;
     }
-    const chunks = await readRawJsonField(message, "chunks", ctx.walletAddress);
-    if (chunks && chunks.length > 0) {
-      const vectors = chunks.map(
+    const chunks2 = await readRawJsonField(message, "chunks", ctx.walletAddress);
+    if (chunks2 && chunks2.length > 0) {
+      const vectors = chunks2.map(
         (chunk) => decodeChunkVector(chunk.vector, () => {
           unreadableVectors++;
         })
       );
       chunkCache?.set(message.id, { version, chunks: vectors });
-      for (let ci = 0; ci < chunks.length; ci++) {
+      for (let ci = 0; ci < chunks2.length; ci++) {
         const vec = vectors[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
@@ -2591,7 +2591,7 @@ async function searchChunksOp(ctx, queryVector, options) {
           candidates.push({
             message,
             similarity,
-            chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+            chunkTextSource: { kind: "chunk", chunk: chunks2[ci], siblings: chunks2 }
           });
         }
       }
@@ -2740,7 +2740,7 @@ function chunkText(text12, options) {
     ];
   }
   const sentences = splitIntoSentences(text12);
-  const chunks = [];
+  const chunks2 = [];
   let currentChunkSentences = [];
   let currentChunkStart = 0;
   let currentOffset = 0;
@@ -2754,7 +2754,7 @@ function chunkText(text12, options) {
     if (sentence.length > chunkSize) {
       if (currentChunkSentences.length > 0) {
         const chunkText2 = currentChunkSentences.join(" ");
-        chunks.push({
+        chunks2.push({
           text: chunkText2,
           startOffset: currentChunkStart,
           endOffset: currentOffset
@@ -2765,7 +2765,7 @@ function chunkText(text12, options) {
         const chunkEnd = Math.min(j + chunkSize, sentence.length);
         const chunk = sentence.slice(j, chunkEnd);
         if (chunk.length >= minChunkSize) {
-          chunks.push({
+          chunks2.push({
             text: chunk,
             startOffset: sentenceStart + j,
             endOffset: sentenceStart + chunkEnd
@@ -2779,7 +2779,7 @@ function chunkText(text12, options) {
     const currentText = currentChunkSentences.join(" ");
     const potentialLength = currentText.length + (currentText ? 1 : 0) + sentence.length;
     if (potentialLength > chunkSize && currentChunkSentences.length > 0) {
-      chunks.push({
+      chunks2.push({
         text: currentText,
         startOffset: currentChunkStart,
         endOffset: currentOffset
@@ -2810,14 +2810,14 @@ function chunkText(text12, options) {
   if (currentChunkSentences.length > 0) {
     const chunkText2 = currentChunkSentences.join(" ");
     if (chunkText2.length >= minChunkSize) {
-      chunks.push({
+      chunks2.push({
         text: chunkText2,
         startOffset: currentChunkStart,
         endOffset: text12.length
       });
     }
   }
-  if (chunks.length === 0) {
+  if (chunks2.length === 0) {
     const trimmedText = text12.trim();
     if (trimmedText.length > 0) {
       return [
@@ -2829,7 +2829,7 @@ function chunkText(text12, options) {
       ];
     }
   }
-  return chunks;
+  return chunks2;
 }
 function shouldChunkMessage(content, chunkSize = DEFAULT_CHUNK_SIZE) {
   return content.length > chunkSize;
@@ -2901,9 +2901,9 @@ function createSseClient({
             if (done) break;
             buffer += value;
             buffer = buffer.replace(/\r\n?/g, "\n");
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
+            const chunks2 = buffer.split("\n\n");
+            buffer = chunks2.pop() ?? "";
+            for (const chunk of chunks2) {
               const lines = chunk.split("\n");
               const dataLines = [];
               let eventName;
@@ -3848,18 +3848,18 @@ async function embedMany(texts, options, outer) {
       outer
     );
   } else {
-    const chunks = [];
+    const chunks2 = [];
     for (let i = 0; i < uncachedTexts.length; i += chunkSize) {
-      chunks.push(uncachedTexts.slice(i, i + chunkSize));
+      chunks2.push(uncachedTexts.slice(i, i + chunkSize));
     }
-    const allEmbeddings = new Array(chunks.length);
+    const allEmbeddings = new Array(chunks2.length);
     let nextIndex = 0;
     const worker = async () => {
-      while (nextIndex < chunks.length) {
+      while (nextIndex < chunks2.length) {
         if (outer?.aborted) throw outer.reason;
         const idx = nextIndex++;
         allEmbeddings[idx] = await generateEmbeddingsBatch(
-          chunks[idx],
+          chunks2[idx],
           headers,
           baseUrl,
           embeddingModel,
@@ -3871,7 +3871,7 @@ async function embedMany(texts, options, outer) {
       }
     };
     const workers = Array.from(
-      { length: Math.min(DEFAULT_EMBEDDING_BATCH_CONCURRENCY, chunks.length) },
+      { length: Math.min(DEFAULT_EMBEDDING_BATCH_CONCURRENCY, chunks2.length) },
       () => worker()
     );
     await Promise.all(workers);
@@ -8507,7 +8507,7 @@ function sseFailureMessage(status, statusText, detail = "") {
   return `SSE failed: ${status} ${statusText}${detail}`;
 }
 function parseSseChunks(raw, incompleteBuffer) {
-  const chunks = [];
+  const chunks2 = [];
   const text12 = incompleteBuffer + raw;
   const lines = text12.split("\n");
   const remaining = raw.endsWith("\n") ? "" : lines.pop() ?? "";
@@ -8516,11 +8516,11 @@ function parseSseChunks(raw, incompleteBuffer) {
     const data = line.substring(6).trim();
     if (data === "[DONE]") continue;
     try {
-      chunks.push(JSON.parse(data));
+      chunks2.push(JSON.parse(data));
     } catch {
     }
   }
-  return { chunks, remaining };
+  return { chunks: chunks2, remaining };
 }
 var xhrTransport = (options) => {
   const queue = [];
@@ -8589,18 +8589,18 @@ var xhrTransport = (options) => {
       const newData = xhr.responseText.substring(lastProcessedIndex);
       lastProcessedIndex = xhr.responseText.length;
       if (newData.length > 0) options.onActivity?.();
-      const { chunks, remaining } = parseSseChunks(newData, incompleteBuffer);
+      const { chunks: chunks2, remaining } = parseSseChunks(newData, incompleteBuffer);
       incompleteBuffer = remaining;
-      for (const chunk of chunks) {
+      for (const chunk of chunks2) {
         push({ type: "data", value: chunk });
       }
     };
     xhr.onload = () => {
       options.signal?.removeEventListener("abort", abortHandler);
       if (incompleteBuffer) {
-        const { chunks } = parseSseChunks(incompleteBuffer + "\n", "");
+        const { chunks: chunks2 } = parseSseChunks(incompleteBuffer + "\n", "");
         incompleteBuffer = "";
-        for (const chunk of chunks) {
+        for (const chunk of chunks2) {
           push({ type: "data", value: chunk });
         }
       }
@@ -18069,6 +18069,65 @@ function createLocalMemoryStore(options) {
   };
 }
 
+// src/lib/memory/store/memoryKeys.ts
+var KEY_ID_DOMAIN = "anuma-private-memory-key-id-v1";
+var MemoryKeyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryKeyError";
+  }
+};
+async function importAesKey(hex) {
+  return crypto.subtle.importKey(
+    "raw",
+    hexToBytes(hex).buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function deriveMemoryKeyRing(signatureHex) {
+  const v3Hex = await deriveKeyFromSignatureV3(signatureHex);
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(`${KEY_ID_DOMAIN}:${v3Hex}`)
+  );
+  const keyId = "v3:" + Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return {
+    keyId,
+    v3: await importAesKey(v3Hex),
+    v2: await importAesKey(await deriveKeyFromSignature(signatureHex))
+  };
+}
+async function decryptWith(value, rings) {
+  const version = value.startsWith("enc:v3:") ? "v3" : "v2";
+  for (const ring of rings) {
+    try {
+      return await decryptDataWithKey(value.slice(`enc:${version}:`.length), ring[version]);
+    } catch {
+      continue;
+    }
+  }
+  throw new MemoryKeyError(`No supplied key decrypts this enc:${version} field`);
+}
+function memoryCipher(canonical) {
+  return {
+    encrypt: async (plaintext) => `enc:v3:${await encryptDataWithKey(plaintext, canonical.v3)}`,
+    decrypt: async (ciphertext) => {
+      if (!ciphertext.startsWith("enc:v3:") || !isEncrypted(ciphertext))
+        throw new MemoryKeyError("Remote memory content must be enc:v3 ciphertext");
+      return decryptWith(ciphertext, [canonical]);
+    }
+  };
+}
+async function reencryptMemoryField(value, canonical, fallbacks = []) {
+  const { encrypt } = memoryCipher(canonical);
+  if (!value.startsWith("enc:")) return encrypt(value);
+  if (!isEncrypted(value))
+    throw new MemoryKeyError("Field has an encryption prefix but an invalid payload");
+  return encrypt(await decryptWith(value, [canonical, ...fallbacks]));
+}
+
 // src/lib/memory/store/remotePersistence.ts
 var RemoteMemoryError = class extends Error {
   constructor(message, status, code) {
@@ -18121,6 +18180,30 @@ var candidateListLimits = [
   ["memory_ids", 1e3],
   ["force_ids", 100]
 ];
+var queryListLimits = [
+  ["scopes", 20],
+  ["fact_types", 20],
+  ["visibility", 20],
+  ["memory_ids", 1e3],
+  ["topics", 100]
+];
+var queryFields = [
+  "include_deleted",
+  "include_archived",
+  "include_quarantined",
+  "include_superseded",
+  "archived_only",
+  "scopes",
+  "fact_types",
+  "visibility",
+  "memory_ids",
+  "topics",
+  "updated_after",
+  "order",
+  "cursor",
+  "limit",
+  "include_embeddings"
+];
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -18455,6 +18538,35 @@ async function createRemoteMemoryPersistence(options) {
         throw new Error("Invalid nearby batch response");
       return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
     },
+    query: async (queryOptions = {}) => {
+      const { signal, ...query } = queryOptions;
+      if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
+        throw new Error("Page limit must be 1\u2013200");
+      for (const [key, max] of queryListLimits) {
+        const values = query[key];
+        if (values && values.length > max)
+          throw new Error(`Query ${key} accepts at most ${max} entries (got ${values.length})`);
+      }
+      const page = await request(
+        "/memories/query",
+        {
+          method: "POST",
+          body: JSON.stringify(
+            Object.fromEntries(
+              queryFields.filter((key) => query[key] !== void 0).map((key) => [key, query[key]])
+            )
+          )
+        },
+        signal
+      );
+      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
+        throw new Error("Invalid nearby private-memory page");
+      return {
+        ...await decodeAll(page.items),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor },
+        ...page.changes_cursor !== void 0 && { changes_cursor: page.changes_cursor }
+      };
+    },
     candidateSet,
     candidates: async (embedding, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding, candidateOptions, false)).items)
   };
@@ -18843,6 +18955,489 @@ function createRemoteMemoryPipeline(options) {
   };
 }
 
+// src/lib/memory/store/remoteStore.ts
+import { v7 as uuidv75 } from "uuid";
+function relevant(change, options) {
+  return options.includeDeleted ? change === "membership" : change !== "embedding" || !!options.embeddings;
+}
+function safely(onChange) {
+  try {
+    onChange();
+  } catch (error) {
+    getLogger().warn("[memory/remote-store] Subscriber threw:", error);
+  }
+}
+var MAX_BATCH = 50;
+var MAX_QUERY_IDS = 1e3;
+var MAX_QUERY_TOPICS = 100;
+var MAX_QUERY_FILTER = 20;
+var RemoteMemoryPartialCreateError = class extends Error {
+  constructor(created, cause) {
+    super(`createMany stored ${created.length} memories before a batch failed`);
+    this.created = created;
+    this.cause = cause;
+    this.name = "RemoteMemoryPartialCreateError";
+  }
+};
+function warnFailed(failed) {
+  if (failed.length)
+    getLogger().warn(
+      `[memory/remote-store] Skipping ${failed.length} undecryptable row(s)`,
+      failed.map((failure) => failure.memory_id)
+    );
+}
+function bounded(filters, key) {
+  const values = filters[key];
+  if (!values || values.length <= MAX_QUERY_FILTER) return [filters];
+  return chunks(values, MAX_QUERY_FILTER).map((chunk) => ({ ...filters, [key]: chunk }));
+}
+function chunks(values, size) {
+  const out = [];
+  for (let i = 0; i < values.length; i += size) out.push(values.slice(i, i + size));
+  return out;
+}
+function stateFilters(options) {
+  return {
+    include_deleted: options.includeDeleted,
+    include_archived: options.includeArchived,
+    include_quarantined: options.includeQuarantined,
+    include_superseded: options.includeSuperseded
+  };
+}
+function hidden(memory, options) {
+  if (memory.trust_tier === "quarantined") return true;
+  if (options.includeDeleted) return false;
+  return !!memory.is_deleted || memory.archived_at !== void 0 && memory.archived_at !== null || !!memory.superseded_by;
+}
+function subscriptionKey({ memory, version }, options) {
+  if (hidden(memory, options)) return void 0;
+  if (options.includeDeleted) return String(!!memory.is_deleted);
+  return JSON.stringify([
+    options.embeddings ? version : null,
+    memory.content,
+    memory.scope,
+    memory.updated_at,
+    memory.fact_type,
+    memory.event_time_start,
+    memory.event_time_end,
+    memory.event_time_kind,
+    memory.trust_tier,
+    memory.visibility,
+    memory.published_at,
+    memory.geohash,
+    memory.topics,
+    memory.topics_user_managed,
+    memory.media,
+    memory.source
+  ]);
+}
+function topicInputs(topics, source) {
+  return topics.flatMap((topic) => {
+    const name = (typeof topic === "string" ? topic : topic.name).trim();
+    const kind = typeof topic === "string" ? void 0 : topic.kind;
+    return name ? [{ name, ...kind && { kind }, source }] : [];
+  });
+}
+function mergeTopics(existing, added) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const topic of [...existing, ...added]) {
+    const key = normalizeEntityName(topic.name);
+    if (!byName.has(key)) byName.set(key, topic);
+  }
+  return [...byName.values()];
+}
+function canonicalTopics(row) {
+  return new Set((parseTopics(row.topics) ?? []).map((topic) => normalizeEntityName(topic.name)));
+}
+function createRemoteMemoryStore(options) {
+  const { persistence, embeddingOptions } = options;
+  const model = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
+  const pollIntervalMs = options.pollIntervalMs ?? 6e4;
+  const pipeline = createRemoteMemoryPipeline(options);
+  const subscribers = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
+  let timer;
+  const notify = (change, records = []) => {
+    if (timer) for (const record2 of records) seen.set(record2.memory.memory_id, record2);
+    for (const subscriber of [...subscribers])
+      if (relevant(change, subscriber.options)) safely(subscriber.onChange);
+  };
+  const enumerate = async (filters, max = Infinity) => {
+    const records = [];
+    let cursor2;
+    do {
+      const page = await persistence.query({
+        ...filters,
+        limit: Math.min(200, Math.max(1, max - records.length)),
+        ...cursor2 && { cursor: cursor2 }
+      });
+      warnFailed(page.failed);
+      records.push(...page.items);
+      cursor2 = page.next_cursor;
+    } while (cursor2 && records.length < max);
+    return records.slice(0, max);
+  };
+  const enumerateIds = async (ids, filters) => (await Promise.all(
+    chunks([...new Set(ids)], MAX_QUERY_IDS).map(
+      (memory_ids) => enumerate({ ...filters, memory_ids })
+    )
+  )).flat();
+  const queues = /* @__PURE__ */ new Map();
+  const serialized = (id, task) => {
+    const run = (queues.get(id) ?? Promise.resolve()).then(task, task);
+    const settled = run.catch(() => void 0);
+    queues.set(id, settled);
+    void settled.then(() => {
+      if (queues.get(id) === settled) queues.delete(id);
+    });
+    return run;
+  };
+  const live = async (id) => {
+    const record2 = await persistence.get(id);
+    return record2 && !record2.memory.is_deleted ? record2 : null;
+  };
+  const mutate = async (id, change, edit) => serialized(id, async () => {
+    const record2 = await live(id);
+    if (!record2) return null;
+    const next = edit(structuredClone(record2.memory));
+    if (!next) return null;
+    const saved = await persistence.put(next, record2);
+    notify(change, [saved]);
+    return saved;
+  });
+  const embedInBackground = ({ memory: { memory_id: id, content } }) => {
+    generateEmbedding(content, embeddingOptions).then(
+      (vector) => serialized(id, async () => {
+        const current = await live(id);
+        if (!current || current.memory.content !== content || current.memory.embedding?.length)
+          return;
+        const saved = await persistence.put(
+          { ...current.memory, embedding: storedVector(vector), embedding_model: model },
+          current
+        );
+        notify("embedding", [saved]);
+      })
+    ).catch((error) => {
+      getLogger().warn("[memory/remote-store] Failed to embed memory:", error);
+    });
+  };
+  const newRow = (input) => {
+    const now = Date.now();
+    const scope = input.scope ?? "private";
+    return {
+      memory_id: uuidv75(),
+      content: input.content,
+      scope,
+      level: levelFromScope(scope),
+      created_at: now,
+      updated_at: now,
+      is_deleted: false,
+      ...input.embedding !== void 0 && {
+        embedding: storedVector(JSON.parse(input.embedding)),
+        embedding_model: input.embeddingModel ?? model
+      },
+      proof_count: 1,
+      source: "manual",
+      ...input.eventTime && {
+        event_time_start: input.eventTime.start ?? void 0,
+        event_time_end: input.eventTime.end ?? void 0,
+        event_time_kind: input.eventTime.kind ?? void 0
+      },
+      fact_type: input.factType,
+      geohash: input.geohash,
+      visibility: "private",
+      twin_opt_in: false
+    };
+  };
+  const created = (records, inputs) => {
+    records.forEach((record2, i) => {
+      if (inputs[i].embedding === void 0) embedInBackground(record2);
+    });
+    notify("membership", records);
+    return records.map((record2) => stored(record2.memory));
+  };
+  const asStored = (record2) => record2 ? stored(record2.memory) : null;
+  const everyState = {
+    include_deleted: true,
+    include_archived: true,
+    include_quarantined: true,
+    include_superseded: true
+  };
+  const changesSince = async (cursor2, pending2) => {
+    const records = [];
+    const failed = /* @__PURE__ */ new Set();
+    const collect = (page) => {
+      warnFailed(page.failed);
+      records.push(...page.items);
+      for (const failure of page.failed) failed.add(failure.memory_id);
+    };
+    let resume = cursor2;
+    let next;
+    do {
+      const page = await persistence.query({
+        ...everyState,
+        order: "changed",
+        limit: 200,
+        ...(next ?? resume) && { cursor: next ?? resume }
+      });
+      collect(page);
+      resume = page.changes_cursor ?? resume;
+      next = page.next_cursor;
+    } while (next);
+    for (const memory_ids of chunks([...pending2], MAX_QUERY_IDS)) {
+      let retry;
+      do {
+        const page = await persistence.query({
+          ...everyState,
+          memory_ids,
+          limit: 200,
+          ...retry && { cursor: retry }
+        });
+        collect(page);
+        retry = page.next_cursor;
+      } while (retry);
+    }
+    return { records, resume, failed };
+  };
+  let generation = 0;
+  let ready = false;
+  let cursor;
+  let pending = /* @__PURE__ */ new Set();
+  let polling = false;
+  const poll = () => {
+    if (polling) return;
+    polling = true;
+    const current = generation;
+    changesSince(cursor, pending).then(({ records, resume, failed }) => {
+      if (current !== generation) return;
+      const changed = /* @__PURE__ */ new Set();
+      for (const record2 of records) {
+        const id = record2.memory.memory_id;
+        const previous = seen.get(id);
+        seen.set(id, record2);
+        if (!ready) continue;
+        for (const subscriber of subscribers) {
+          const before = previous && subscriptionKey(previous, subscriber.options);
+          if (before !== subscriptionKey(record2, subscriber.options)) changed.add(subscriber);
+        }
+      }
+      ready = true;
+      cursor = resume;
+      pending = failed;
+      for (const subscriber of changed)
+        if (subscribers.has(subscriber)) safely(subscriber.onChange);
+    }).catch((error) => {
+      getLogger().warn("[memory/remote-store] Subscription poll failed:", error);
+    }).finally(() => {
+      polling = false;
+    });
+  };
+  return {
+    list: async (listOptions = {}) => {
+      const order = listOptions.since ? "updated" : "created";
+      const filters = {
+        ...stateFilters(listOptions),
+        include_embeddings: true,
+        order,
+        ...listOptions.scopes?.length && { scopes: listOptions.scopes },
+        ...listOptions.factTypes?.length && { fact_types: listOptions.factTypes },
+        ...listOptions.visibility?.length && { visibility: listOptions.visibility },
+        ...listOptions.since && { updated_after: listOptions.since.getTime() }
+      };
+      const max = listOptions.limit && listOptions.limit > 0 ? listOptions.limit : Infinity;
+      const variants = bounded(filters, "scopes").flatMap((f) => bounded(f, "fact_types"));
+      if (!listOptions.memoryIds && variants.length === 1)
+        return (await enumerate(filters, max)).map((r) => stored(r.memory));
+      const fetched = await Promise.all(
+        variants.map(
+          (variant) => listOptions.memoryIds ? enumerateIds(listOptions.memoryIds, variant) : enumerate(variant, max)
+        )
+      );
+      const rows = [...new Map(fetched.flat().map((r) => [r.memory.memory_id, r])).values()].map((record2) => stored(record2.memory)).sort(
+        (a, b) => order === "updated" ? b.updatedAt.getTime() - a.updatedAt.getTime() || (a.uniqueId < b.uniqueId ? 1 : -1) : b.createdAt.getTime() - a.createdAt.getTime() || (a.uniqueId < b.uniqueId ? 1 : -1)
+      );
+      return rows.slice(0, max);
+    },
+    get: async (id) => asStored(await live(id)),
+    listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
+      (record2) => stored(record2.memory)
+    ),
+    memoriesByTopics: async (names) => {
+      const wanted = new Set(names.map(normalizeEntityName).filter(Boolean));
+      const out = /* @__PURE__ */ new Map();
+      const pages = await Promise.all(
+        chunks([...wanted], MAX_QUERY_TOPICS).map((topics) => enumerate({ topics }))
+      );
+      for (const { memory } of pages.flat()) {
+        const matched = [...canonicalTopics(memory)].filter((name) => wanted.has(name));
+        if (matched.length) out.set(memory.memory_id, new Set(matched));
+      }
+      return out;
+    },
+    topicsByMemories: async (memoryIds) => {
+      const out = /* @__PURE__ */ new Map();
+      for (const { memory } of await enumerateIds(memoryIds, {
+        include_archived: true,
+        include_superseded: true,
+        include_quarantined: true
+      })) {
+        const topics = canonicalTopics(memory);
+        if (topics.size) out.set(memory.memory_id, topics);
+      }
+      return out;
+    },
+    create: async (input) => {
+      const record2 = await persistence.put(newRow(input), 0);
+      return created([record2], [input])[0];
+    },
+    createMany: async (inputs) => {
+      const out = [];
+      for (const batch of chunks(inputs, MAX_BATCH)) {
+        let records;
+        try {
+          records = await persistence.putMany(
+            batch.map((input) => ({ memory: newRow(input), expectedVersion: 0 }))
+          );
+        } catch (error) {
+          if (out.length === 0) throw error;
+          throw new RemoteMemoryPartialCreateError(out, error);
+        }
+        out.push(...created(records, batch));
+      }
+      return out;
+    },
+    update: async (id, patch) => {
+      const saved = await mutate(id, "edit", (memory) => {
+        if (memory.superseded_by) return null;
+        memory.content = patch.content;
+        memory.updated_at = Date.now();
+        if (patch.scope !== void 0) {
+          memory.level = levelForScopeChange(
+            { level: memory.level, scope: memory.scope },
+            patch.scope
+          );
+          memory.scope = patch.scope;
+        }
+        if (patch.factType !== void 0) memory.fact_type = patch.factType ?? void 0;
+        if (patch.eventTime !== void 0) {
+          memory.event_time_start = patch.eventTime?.start ?? void 0;
+          memory.event_time_end = patch.eventTime?.end ?? void 0;
+          memory.event_time_kind = patch.eventTime?.kind ?? void 0;
+        }
+        if (patch.embedding === void 0 || patch.embedding === null) {
+          memory.embedding = [];
+          delete memory.embedding_model;
+        } else {
+          memory.embedding = storedVector(JSON.parse(patch.embedding));
+          memory.embedding_model = patch.embeddingModel ?? model;
+        }
+        return memory;
+      });
+      if (saved && patch.embedding === void 0) embedInBackground(saved);
+      return asStored(saved);
+    },
+    delete: async (id) => !!await mutate(id, "membership", (memory) => ({ ...memory, is_deleted: true })),
+    supersede: async (id, supersededById) => {
+      if (id === supersededById) return false;
+      const [first, second] = [id, supersededById].sort();
+      return serialized(
+        first,
+        () => serialized(second, async () => {
+          const [old, next] = await Promise.all([live(id), live(supersededById)]);
+          if (!old || !next || old.memory.superseded_by || next.memory.superseded_by) return false;
+          if (old.memory.kind !== void 0 && old.memory.kind !== null) return false;
+          const saved = await persistence.putMany([
+            {
+              memory: { ...old.memory, superseded_by: supersededById, superseded_at: Date.now() },
+              expectedVersion: old
+            },
+            { memory: next.memory, expectedVersion: next }
+          ]);
+          notify("membership", saved);
+          return true;
+        })
+      );
+    },
+    archive: async (id) => !!await mutate(
+      id,
+      "edit",
+      (memory) => memory.archived_at === void 0 || memory.archived_at === null ? { ...memory, archived_at: Date.now() } : null
+    ),
+    restore: (id) => serialized(id, async () => {
+      const record2 = await live(id);
+      if (!record2) return false;
+      if (record2.memory.archived_at === void 0 || record2.memory.archived_at === null)
+        return true;
+      const { archived_at: _archivedAt, ...memory } = record2.memory;
+      notify("edit", [await persistence.put(memory, record2)]);
+      return true;
+    }),
+    setTopics: async (memoryId, topics) => asStored(
+      await mutate(memoryId, "edit", (memory) => ({
+        ...memory,
+        topics: serializeTopics(mergeTopics([], topicInputs(topics, "user"))),
+        topics_user_managed: true,
+        topics_updated_at: Date.now()
+      }))
+    ),
+    addTopics: async (memoryId, topics) => {
+      const added = topicInputs(topics, "auto");
+      const saved = await mutate(memoryId, "edit", (memory) => ({
+        ...memory,
+        topics: serializeTopics(mergeTopics(parseTopics(memory.topics) ?? [], added)),
+        topics_updated_at: Date.now()
+      }));
+      if (!saved) return [];
+      const now = /* @__PURE__ */ new Date();
+      return mergeTopics([], added).map(
+        (topic) => ({
+          uniqueId: normalizeEntityName(topic.name),
+          canonicalName: normalizeEntityName(topic.name),
+          kind: topic.kind ?? null,
+          createdAt: now,
+          updatedAt: now
+        })
+      );
+    },
+    setVisibility: async (id, visibility, visibilityOptions) => asStored(
+      await mutate(id, "edit", (memory) => {
+        memory.visibility = visibility;
+        if (visibility === "private") delete memory.published_at;
+        else memory.published_at ?? (memory.published_at = Date.now());
+        if (visibilityOptions?.twinOptIn !== void 0)
+          memory.twin_opt_in = visibilityOptions.twinOptIn;
+        return memory;
+      })
+    ),
+    recall: (query, recallOptions) => pipeline.recall(query, recallOptions),
+    retain: async (content, retainOptions) => {
+      const result = await pipeline.retain(content, retainOptions);
+      if (result.action === "create" || result.action === "supersede") notify("membership");
+      else if (result.action === "update" || result.action === "merge") notify("edit");
+      return result;
+    },
+    subscribe: (onChange, subscribeOptions = {}) => {
+      const subscriber = { onChange, options: subscribeOptions };
+      subscribers.add(subscriber);
+      if (pollIntervalMs > 0 && !timer) {
+        timer = setInterval(poll, pollIntervalMs);
+        poll();
+      }
+      return () => {
+        subscribers.delete(subscriber);
+        if (subscribers.size || !timer) return;
+        clearInterval(timer);
+        timer = void 0;
+        generation++;
+        seen.clear();
+        ready = false;
+        cursor = void 0;
+        pending = /* @__PURE__ */ new Set();
+      };
+    }
+  };
+}
+
 // src/lib/memory/synthesizeProfile.ts
 var DEFAULT_SYNTHESIS_MODEL = "inclusionai/ling-2.6-flash";
 var DEFAULT_FACET_RECALL_LIMIT = 20;
@@ -22253,7 +22848,7 @@ function useChat(options) {
 
 // src/expo/useChatStorage.ts
 import { useCallback as useCallback4, useEffect as useEffect4, useMemo, useRef as useRef4, useState as useState4 } from "react";
-import { v7 as uuidv76 } from "uuid";
+import { v7 as uuidv77 } from "uuid";
 
 // src/lib/chat/assembleMessages.ts
 function assembleMessagesWithHistory(historyMessages, callerMessages, summarySystemMessage) {
@@ -22910,9 +23505,9 @@ async function decryptMediaFields(media, address, signMessage, embeddedWalletSig
 }
 
 // src/lib/db/media/types.ts
-import { v7 as uuidv75 } from "uuid";
+import { v7 as uuidv76 } from "uuid";
 function generateMediaId() {
-  return `media_${uuidv75()}`;
+  return `media_${uuidv76()}`;
 }
 
 // src/lib/db/media/operations.ts
@@ -23868,7 +24463,7 @@ function useChatStorage(options) {
         };
       };
       pendingResumeRef.current = null;
-      const effectiveAssistantUniqueId = assistantUniqueId ?? (resumable ? `msg_${uuidv76()}` : void 0);
+      const effectiveAssistantUniqueId = assistantUniqueId ?? (resumable ? `msg_${uuidv77()}` : void 0);
       const embedToolText = (text12, mask, masked, token) => {
         const opts = {
           getToken: token,
@@ -24386,7 +24981,7 @@ function useChatStorage(options) {
       const detachedResult = result;
       if (detachedResult.detached) {
         recordToolSetTurn(database, convId, matchedToolSets);
-        const rowId = effectiveAssistantUniqueId ?? `msg_${uuidv76()}`;
+        const rowId = effectiveAssistantUniqueId ?? `msg_${uuidv77()}`;
         pendingResumeRef.current = {
           handle: detachedResult.resume ?? null,
           convId,
@@ -24897,6 +25492,7 @@ export {
   MEDIUM_TTL_MS,
   MEMORY_KINDS,
   MEMORY_LEVELS,
+  MemoryKeyError,
   MemoryLevelError,
   NEVER_TTL_MS,
   NODE_BUDGET,
@@ -24909,6 +25505,7 @@ export {
   RECALL_MAX_LIMIT,
   RECALL_TOOL_NAME,
   RemoteMemoryError,
+  RemoteMemoryPartialCreateError,
   RerankerUnavailableError,
   SDK_SCHEMA_VERSION,
   SHORT_TTL_MS,
@@ -24974,6 +25571,7 @@ export {
   createRecallTool,
   createRemoteMemoryPersistence,
   createRemoteMemoryPipeline,
+  createRemoteMemoryStore,
   createStockPricePreProcessor,
   createStreamingDeAnonymizer,
   createVaultEmbeddingCache,
@@ -24990,6 +25588,7 @@ export {
   deleteVaultMemoryOp,
   dequantizeEmbedding,
   deriveKeyFromSignatureBytes,
+  deriveMemoryKeyRing,
   discoverNotionOAuthEndpoints,
   eagerEmbedContent,
   embedAllMessages,
@@ -25033,6 +25632,7 @@ export {
   isPiiRedactor,
   isRerankerAvailable,
   maskScopedEmbeddingCache,
+  memoryCipher,
   moveMemoriesToFolderOp,
   noopLogger,
   onKeyAvailable,
@@ -25042,6 +25642,7 @@ export {
   queueManager,
   rankProfileCandidates,
   recall,
+  reencryptMemoryField,
   reflect,
   refreshEncryptionKeyIfMatches,
   refreshNotionAccessToken,