@anuma/sdk 10.10.0 → 11.0.1

package/dist/react/index.mjs

@@ -544,9 +544,9 @@ async function refreshEncryptionKeyIfMatches(walletAddress, probeCiphertext, sig
     return false;
   }
   const startEpoch = sessionEpoch;
-  const cached = refreshCandidatesByAddress.get(walletAddress);
-  if (cached) {
-    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached, startEpoch);
+  const cached2 = refreshCandidatesByAddress.get(walletAddress);
+  if (cached2) {
+    return tryCommitCandidatesIfProbeMatches(walletAddress, parsed, cached2, startEpoch);
   }
   let derivePromise = pendingCandidateDerives.get(walletAddress);
   if (!derivePromise) {
@@ -895,10 +895,10 @@ function parsePlaintextToken(raw, walletAddress) {
     return null;
   }
   if (!parsed || typeof parsed !== "object") return null;
-  const record2 = parsed;
-  const data = record2.token?.accessToken ? record2.token : record2;
+  const record3 = parsed;
+  const data = record3.token?.accessToken ? record3.token : record3;
   if (!data?.accessToken) return null;
-  if (record2.wallet && record2.wallet !== walletAddress) return null;
+  if (record3.wallet && record3.wallet !== walletAddress) return null;
   return data;
 }
 function promoteUnscopedRow(raw, data, store, scopedKey, unscopedKey, walletAddress) {
@@ -990,10 +990,10 @@ async function discoverOAuthMetadata() {
 }
 async function getOAuthMetadata() {
   if (typeof window !== "undefined") {
-    const cached = sessionStorage.getItem(OAUTH_METADATA_KEY);
-    if (cached) {
+    const cached2 = sessionStorage.getItem(OAUTH_METADATA_KEY);
+    if (cached2) {
       try {
-        return JSON.parse(cached);
+        return JSON.parse(cached2);
       } catch {
       }
     }
@@ -1097,8 +1097,8 @@ async function storeTokenData(data, walletAddress) {
     } catch {
     }
   }
-  const record2 = { wallet: walletAddress, token: data };
-  sessionStorage.setItem(getTokenStorageKey(walletAddress), JSON.stringify(record2));
+  const record3 = { wallet: walletAddress, token: data };
+  sessionStorage.setItem(getTokenStorageKey(walletAddress), JSON.stringify(record3));
 }
 async function getStoredTokenData(walletAddress) {
   if (typeof window === "undefined") return null;
@@ -1502,25 +1502,25 @@ var TRUNCATION_MARKER_HEAD = "... (tool output truncated, ";
 var TRUNCATION_MARKER_TAIL = " characters omitted)";
 var MAX_PERSISTED_TOOL_RESULT_CHARS = 1e5;
 function buildToolResultContent(results) {
-  const entries = results.map(
+  const entries2 = results.map(
     (r) => `Tool "${r.name}" returned: ${JSON.stringify(r.result)}`.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029")
   );
-  const framing = HEADER.length + FOOTER.length + ENTRY_SEPARATOR.length * Math.max(0, entries.length - 1);
-  const summary = capEntries(entries, MAX_PERSISTED_TOOL_RESULT_CHARS - framing).join(
+  const framing = HEADER.length + FOOTER.length + ENTRY_SEPARATOR.length * Math.max(0, entries2.length - 1);
+  const summary = capEntries(entries2, MAX_PERSISTED_TOOL_RESULT_CHARS - framing).join(
     ENTRY_SEPARATOR
   );
   return `${HEADER}${summary}${FOOTER}`;
 }
-function capToolResultEntries(entries, budget) {
-  return capEntries(entries, budget);
+function capToolResultEntries(entries2, budget) {
+  return capEntries(entries2, budget);
 }
-function capEntries(entries, budget) {
-  const smallestFirst = entries.map((_, index) => index).sort((a, b) => entries[a].length - entries[b].length);
-  const capped = [...entries];
+function capEntries(entries2, budget) {
+  const smallestFirst = entries2.map((_, index) => index).sort((a, b) => entries2[a].length - entries2[b].length);
+  const capped = [...entries2];
   let remaining = budget;
-  let unassigned = entries.length;
+  let unassigned = entries2.length;
   for (const index of smallestFirst) {
-    capped[index] = truncateEntry(entries[index], Math.floor(remaining / unassigned));
+    capped[index] = truncateEntry(entries2[index], Math.floor(remaining / unassigned));
     remaining -= capped[index].length;
     unassigned--;
   }
@@ -2408,11 +2408,11 @@ var ToolCallEventIndex = class {
     this.pending = /* @__PURE__ */ new Map();
     this.resetCount = collection.database._resetCount;
     collection.experimentalSubscribe((changes) => {
-      for (const { record: record2, type } of changes) {
+      for (const { record: record3, type } of changes) {
         this.replace(
-          record2.id,
-          type === "destroyed" ? void 0 : record2.conversationId,
-          type === "destroyed" ? void 0 : record2._getRaw("tool_call_events")
+          record3.id,
+          type === "destroyed" ? void 0 : record3.conversationId,
+          type === "destroyed" ? void 0 : record3._getRaw("tool_call_events")
         );
       }
     });
@@ -3855,15 +3855,15 @@ async function searchChunksOp(ctx, queryVector, options) {
       staleSkipped++;
       continue;
     }
-    const cached = chunkCache?.get(key3.id);
-    if (!cached || cached.version !== key3.version) {
+    const cached2 = chunkCache?.get(key3.id);
+    if (!cached2 || cached2.version !== key3.version) {
       missIds.push(key3.id);
       continue;
     }
     cacheHits++;
-    if (cached.chunks.length > 0) {
-      for (let ci = 0; ci < cached.chunks.length; ci++) {
-        const vec = cached.chunks[ci];
+    if (cached2.chunks.length > 0) {
+      for (let ci = 0; ci < cached2.chunks.length; ci++) {
+        const vec = cached2.chunks[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
         if (similarity >= minSimilarity) {
@@ -3876,8 +3876,8 @@ async function searchChunksOp(ctx, queryVector, options) {
           });
         }
       }
-    } else if (cached.fallback) {
-      const similarity = cosineSimilarity(queryVector, cached.fallback);
+    } else if (cached2.fallback) {
+      const similarity = cosineSimilarity(queryVector, cached2.fallback);
       if (similarity >= minSimilarity) {
         candidates.push({
           id: key3.id,
@@ -4690,11 +4690,11 @@ var mergeConfigs = (a, b) => {
   return config;
 };
 var headersEntries = (headers) => {
-  const entries = [];
+  const entries2 = [];
   headers.forEach((value, key3) => {
-    entries.push([key3, value]);
+    entries2.push([key3, value]);
   });
-  return entries;
+  return entries2;
 };
 var mergeHeaders = (...headers) => {
   const mergedHeaders = new Headers();
@@ -5169,9 +5169,9 @@ async function embedOne(text16, options, outer) {
   const { cache } = options;
   if (!cache) return Array.from(await requestEmbedding(text16, options, outer));
   const model = options.model ?? DEFAULT_API_EMBEDDING_MODEL;
-  const cached = cache.get(text16);
-  const cachedModel = cached && cachedEmbeddingModels.get(cached);
-  if (cached && (cachedModel === void 0 || cachedModel === model)) return Array.from(cached);
+  const cached2 = cache.get(text16);
+  const cachedModel = cached2 && cachedEmbeddingModels.get(cached2);
+  if (cached2 && (cachedModel === void 0 || cachedModel === model)) return Array.from(cached2);
   const inFlight = inFlightByCache.get(cache) ?? /* @__PURE__ */ new Map();
   inFlightByCache.set(cache, inFlight);
   const requestKey = JSON.stringify([model, text16]);
@@ -5286,10 +5286,10 @@ async function embedMany(texts, options, outer) {
   const uncachedTexts = [];
   for (let i = 0; i < texts.length; i++) {
     if (cache) {
-      const cached = cache.get(texts[i]);
-      const cachedModel = cached && cachedEmbeddingModels.get(cached);
-      if (cached && (cachedModel === void 0 || cachedModel === embeddingModel)) {
-        results[i] = Array.from(cached);
+      const cached2 = cache.get(texts[i]);
+      const cachedModel = cached2 && cachedEmbeddingModels.get(cached2);
+      if (cached2 && (cachedModel === void 0 || cachedModel === embeddingModel)) {
+        results[i] = Array.from(cached2);
         continue;
       }
     }
@@ -5730,58 +5730,337 @@ function parseTopics(value) {
   return out;
 }
 
+// src/lib/memory/store/topicCodec.ts
+var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var topicHashPattern = /^[0-9a-f]{64}$/;
+var MAX_SEALED_TOPIC_NAME_BYTES = 1024;
+function normalizeTopicName(name) {
+  return normalizeEntityName(name).normalize("NFC");
+}
+function sealedTopicNamesFit(json5) {
+  return (entries(json5) ?? []).every(
+    (entry) => !hashed(entry) || typeof entry.name !== "string" || entry.name.length <= MAX_SEALED_TOPIC_NAME_BYTES
+  );
+}
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hashed(entry) {
+  return record(entry) && typeof entry.name_hash === "string";
+}
+function entries(json5) {
+  if (typeof json5 !== "string") return void 0;
+  try {
+    const parsed = JSON.parse(json5);
+    return Array.isArray(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function cached(cache, key3, load) {
+  let pending = cache.get(key3);
+  if (!pending) {
+    const loading = load();
+    pending = loading;
+    cache.set(key3, loading);
+    loading.catch(() => {
+      if (cache.get(key3) === loading) cache.delete(key3);
+    });
+  }
+  return pending;
+}
+function createTopicCodec(cipher) {
+  const hashes = /* @__PURE__ */ new Map();
+  const opened = /* @__PURE__ */ new Map();
+  const seals = /* @__PURE__ */ new Map();
+  const legacyNames = /* @__PURE__ */ new Map();
+  const hash = async (name) => {
+    const normalized2 = normalizeTopicName(name);
+    if (!normalized2) return null;
+    return cached(hashes, normalized2, async () => {
+      const digest = await cipher.hashTopic(normalized2);
+      if (!topicHashPattern.test(digest))
+        throw new Error("Topic hashing must return 64 lowercase hex characters");
+      return digest;
+    });
+  };
+  const seal = async (display) => {
+    const nameHash = await hash(display);
+    if (nameHash === null) return null;
+    return cached(seals, display, async () => {
+      const name = await cipher.encrypt(display);
+      if (name === display || !ciphertextPattern.test(name))
+        throw new Error(
+          "Topic encryption must return SDK ciphertext; refusing to upload plaintext"
+        );
+      opened.set(name, Promise.resolve(display));
+      return { name_hash: nameHash, name };
+    });
+  };
+  const plain2 = (name) => {
+    if (!ciphertextPattern.test(name)) return Promise.resolve(name);
+    let pending = legacyNames.get(name);
+    if (!pending) {
+      pending = cipher.decrypt(name).catch(() => name);
+      legacyNames.set(name, pending);
+    }
+    return pending;
+  };
+  const open = async ({ name, name_hash: nameHash }) => {
+    if (nameHash === void 0) return plain2(name);
+    if (typeof name !== "string" || typeof nameHash !== "string" || !topicHashPattern.test(nameHash) || !ciphertextPattern.test(name))
+      throw new Error("Nearby returned a malformed topic name");
+    const plaintext = await cached(opened, name, async () => {
+      const value = await cipher.decrypt(name);
+      if (value === name) throw new Error("Topic decryption failed");
+      return value;
+    });
+    if (await hash(plaintext) !== nameHash) throw new Error("Topic name does not match its hash");
+    if (!seals.has(plaintext)) seals.set(plaintext, Promise.resolve({ name_hash: nameHash, name }));
+    return plaintext;
+  };
+  return {
+    hash,
+    seal,
+    open,
+    encodeTopics: async (json5) => {
+      const list = entries(json5);
+      if (!list) return json5;
+      const sealed2 = await Promise.all(
+        list.map(async (entry) => {
+          if (!record(entry) || typeof entry.name !== "string") return null;
+          const name = await seal(await plain2(entry.name));
+          return name && { ...entry, name: name.name, name_hash: name.name_hash };
+        })
+      );
+      return JSON.stringify(sealed2.filter((entry) => entry !== null));
+    },
+    decodeTopics: async (json5) => {
+      const list = entries(json5);
+      if (!list?.some(
+        (entry) => hashed(entry) || record(entry) && typeof entry.name === "string" && ciphertextPattern.test(entry.name)
+      ))
+        return json5;
+      const decoded = await Promise.all(
+        list.map(async (entry) => {
+          if (!hashed(entry))
+            return record(entry) && typeof entry.name === "string" ? { ...entry, name: await plain2(entry.name) } : entry;
+          const { name_hash: nameHash, ...rest } = entry;
+          return { ...rest, name: await open({ name: entry.name, name_hash: nameHash }) };
+        })
+      );
+      return JSON.stringify(decoded);
+    },
+    isLegacy: (json5) => (entries(json5) ?? []).some(
+      (entry) => record(entry) && typeof entry.name === "string" && !hashed(entry)
+    ),
+    matchesLegacy: async (json5, names, hashes2) => {
+      const list = typeof json5 === "string" ? entries(json5) ?? [] : [];
+      if (list.some((entry) => hashed(entry) && hashes2.has(entry.name_hash))) return false;
+      const legacy = await Promise.all(
+        list.map(
+          async (entry) => record(entry) && typeof entry.name === "string" && !hashed(entry) ? normalizeTopicName(await plain2(entry.name)) : null
+        )
+      );
+      return legacy.some((name) => name !== null && names.has(name));
+    },
+    encodeCatalog: async (topic2) => {
+      const sealed2 = await seal(normalizeTopicName(await plain2(topic2.name)));
+      return sealed2 && { ...topic2, name: sealed2.name, name_hash: sealed2.name_hash };
+    },
+    decodeCatalog: async (item) => {
+      const { name_hash: nameHash, ...rest } = item;
+      return { ...rest, name: await open({ name: item.name, name_hash: nameHash }) };
+    }
+  };
+}
+
 // src/lib/memory/store/remoteTopics.ts
+var RETIRE_CONCURRENCY = 8;
 function topic(value) {
   const t = value;
-  if (!t || typeof t.name !== "string" || !t.name || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
+  if (!t || typeof t.name !== "string" || !t.name || t.name_hash !== void 0 && typeof t.name_hash !== "string" || !Number.isSafeInteger(t.version) || t.version < 1 || typeof t.is_deleted !== "boolean" || typeof t.server_updated_at !== "string" || t.kind !== void 0 && typeof t.kind !== "string")
     throw new Error("Invalid nearby topic");
   return t;
 }
-function createRemoteTopicPersistence(request) {
+async function wireTopics(request, signal) {
+  const out = [];
+  let cursor;
+  do {
+    const page = await request(
+      "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
+      {},
+      signal
+    );
+    if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
+      throw new Error("Invalid nearby topic page");
+    out.push(...page.items.map(topic));
+    cursor = page.next_cursor;
+  } while (cursor);
+  return out;
+}
+function hashesOf(items) {
+  return new Set(items.flatMap((t) => t.name_hash === void 0 ? [] : [t.name_hash]));
+}
+async function sealedImport(request, codec, topics, signal) {
+  let oversized = 0;
+  for (let i = 0; i < topics.length; i += 50) {
+    signal?.throwIfAborted();
+    const sealed2 = (await Promise.all(topics.slice(i, i + 50).map((t) => codec.encodeCatalog(t)))).filter((t) => {
+      if (t === null) return false;
+      if (t.name.length <= MAX_SEALED_TOPIC_NAME_BYTES) return true;
+      oversized++;
+      return false;
+    });
+    if (sealed2.length)
+      await request(
+        "/topics/import",
+        { method: "POST", body: JSON.stringify({ topics: sealed2 }) },
+        signal
+      );
+  }
+  signal?.throwIfAborted();
+  if (oversized)
+    getLogger().warn(
+      `[memory/remote] Skipped ${oversized} topic catalog entries whose sealed name exceeds ${MAX_SEALED_TOPIC_NAME_BYTES} bytes`
+    );
+}
+function createRemoteTopicPersistence(request, codec) {
+  let legacyOnly = /* @__PURE__ */ new Set();
   return {
     topics: async () => {
-      const out = [];
-      let cursor;
-      do {
-        const page = await request(
-          "/topics?limit=200" + (cursor ? `&cursor=${encodeURIComponent(cursor)}` : ""),
-          {}
-        );
-        if (!Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string")
-          throw new Error("Invalid nearby topic page");
-        out.push(...page.items.map(topic));
-        cursor = page.next_cursor;
-      } while (cursor);
-      return out;
+      const items = await wireTopics(request);
+      const hashed2 = hashesOf(items);
+      const legacy = /* @__PURE__ */ new Set();
+      const decoded = await Promise.all(
+        items.map(async (item) => {
+          const plain2 = await codec.decodeCatalog(item);
+          const name = normalizeTopicName(plain2.name);
+          if (item.name_hash === void 0) {
+            const hash = await codec.hash(name);
+            if (hash !== null && hashed2.has(hash)) return null;
+            legacy.add(name);
+          }
+          return { ...plain2, name };
+        })
+      );
+      legacyOnly = legacy;
+      return decoded.filter((t) => t !== null);
     },
     putTopic: async (value, expectedVersion) => {
       if (!Number.isSafeInteger(expectedVersion) || expectedVersion < 0)
         throw new Error("Expected topic version must be a nonnegative integer");
-      return topic(
+      const sealed2 = await codec.encodeCatalog(value);
+      if (!sealed2) throw new Error("Topic name must not be empty");
+      const saved = topic(
         await request("/topics", {
           method: "PUT",
-          body: JSON.stringify({ topic: value, expected_version: expectedVersion })
+          body: JSON.stringify({
+            topic: sealed2,
+            expected_version: legacyOnly.has(normalizeTopicName(value.name)) ? 0 : expectedVersion
+          })
         })
       );
-    },
-    importTopics: async (topics, signal) => {
-      for (let i = 0; i < topics.length; i += 50) {
-        signal?.throwIfAborted();
-        await request(
-          "/topics/import",
-          {
-            method: "POST",
-            body: JSON.stringify({ topics: topics.slice(i, i + 50) })
-          },
-          signal
-        );
-      }
+      const decoded = await codec.decodeCatalog(saved);
+      legacyOnly.delete(decoded.name);
+      return decoded;
+    },
+    importTopics: (topics, signal) => sealedImport(
+      request,
+      codec,
+      topics.map(({ name, kind }) => ({ name, ...kind !== void 0 && { kind } })),
+      signal
+    )
+  };
+}
+async function retireLegacyTopics(request, codec, topics, imported, signal) {
+  const failures = [];
+  const put = async (topic2, expectedVersion) => {
+    try {
+      await request(
+        "/topics",
+        { method: "PUT", body: JSON.stringify({ topic: topic2, expected_version: expectedVersion }) },
+        signal
+      );
+      return "saved";
+    } catch (error) {
+      if (signal?.aborted) throw error;
+      if (error instanceof RemoteMemoryError && error.status === 409) return "conflict";
+      failures.push(error);
+      return "failed";
+    }
+  };
+  const retire = (item) => put(
+    { name: item.name, ...item.kind !== void 0 && { kind: item.kind }, is_deleted: true },
+    item.version
+  );
+  const changed = [];
+  let next = 0;
+  const worker = async () => {
+    while (next < topics.length) {
       signal?.throwIfAborted();
+      const item = topics[next++];
+      if (await retire(item) === "conflict") changed.push(item);
     }
   };
+  await Promise.all(
+    Array.from({ length: Math.min(RETIRE_CONCURRENCY, topics.length) }, () => worker())
+  );
+  if (changed.length) {
+    const current = await wireTopics(request, signal);
+    for (const stale of changed) {
+      const legacy = current.find((t) => t.name_hash === void 0 && t.name === stale.name);
+      if (!legacy || legacy.is_deleted) continue;
+      const hash = await codec.hash(await codec.open(legacy));
+      const copy = current.find((t) => t.name_hash !== void 0 && t.name_hash === hash);
+      if (!copy || hash === null) continue;
+      const newer = imported.has(hash) || Date.parse(legacy.server_updated_at) > Date.parse(copy.server_updated_at);
+      if (newer && (copy.is_deleted || legacy.kind !== copy.kind)) {
+        const sealed2 = await codec.encodeCatalog({
+          name: legacy.name,
+          ...legacy.kind !== void 0 && { kind: legacy.kind },
+          is_deleted: false
+        });
+        if (!sealed2 || await put(sealed2, copy.version) !== "saved") continue;
+      }
+      await retire(legacy);
+    }
+  }
+  if (failures.length)
+    getLogger().warn(
+      `[memory/remote] Could not retire ${failures.length} upgraded topic catalog entries:`,
+      failures[0]
+    );
+}
+async function upgradeLegacyTopicCatalog(request, codec, signal) {
+  const items = await wireTopics(request, signal);
+  const hashed2 = hashesOf(items);
+  const hashes = await Promise.all(
+    items.map(
+      async (item) => item.name_hash === void 0 ? codec.hash(await codec.open(item)) : null
+    )
+  );
+  const sources = /* @__PURE__ */ new Map();
+  const live2 = [];
+  items.forEach((item, i) => {
+    const hash = hashes[i];
+    if (hash === null) return;
+    if (!item.is_deleted) live2.push(item);
+    if (hashed2.has(hash)) return;
+    const source = sources.get(hash);
+    if (!source || source.is_deleted && !item.is_deleted) sources.set(hash, item);
+  });
+  const legacy = [...sources.values()].map((item) => ({
+    name: item.name,
+    ...item.kind !== void 0 && { kind: item.kind },
+    ...item.is_deleted && { is_deleted: true }
+  }));
+  await sealedImport(request, codec, legacy, signal);
+  await retireLegacyTopics(request, codec, live2, new Set(sources.keys()), signal);
+  return legacy.length;
 }
 async function createRemoteTopic(persistence, name) {
-  const canonical = normalizeEntityName(name);
+  const canonical = normalizeTopicName(name);
   if (!canonical) return null;
   const existing = (await persistence.topics()).find((t) => t.name === canonical);
   if (existing && !existing.is_deleted) return canonical;
@@ -5869,7 +6148,10 @@ var RemoteMemoryError = class extends Error {
     this.name = "RemoteMemoryError";
   }
 };
-var ciphertextPattern = /^enc:v\d+:[0-9a-f]+$/i;
+var TOPIC_UPGRADE_PROCESSOR = "topic-hash-v1";
+var TOPIC_UPGRADE_PAGE = 50;
+var LEGACY_TOPIC_CURSOR = "legacy-topics:";
+var LEGACY_TOPIC_RECHECK_MS = 6e4;
 var memoryFields = {
   memory_id: true,
   content: true,
@@ -5929,7 +6211,8 @@ var queryFields = [
   "fact_types",
   "visibility",
   "memory_ids",
-  "topics",
+  "topic_hashes",
+  "topics_legacy",
   "updated_after",
   "topics_due",
   "topics_extracted",
@@ -5939,11 +6222,17 @@ var queryFields = [
   "limit",
   "include_embeddings"
 ];
-function record(value) {
+function isVersionConflict(error) {
+  return error instanceof RemoteMemoryError && error.code === "version_conflict";
+}
+function isRejectedRow(error) {
+  return error instanceof RemoteMemoryError && error.status === 400;
+}
+function record2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function memoryRecord(value) {
-  if (!record(value) || !record(value.memory) || typeof value.memory.memory_id !== "string" || typeof value.memory.content !== "string" || typeof value.memory.scope !== "string" || typeof value.memory.created_at !== "number" || typeof value.memory.updated_at !== "number" || typeof value.memory.is_deleted !== "boolean" || !Number.isSafeInteger(value.version) || value.version < 1 || typeof value.server_updated_at !== "string" || value.score !== void 0 && (typeof value.score !== "number" || !Number.isFinite(value.score))) {
+  if (!record2(value) || !record2(value.memory) || typeof value.memory.memory_id !== "string" || typeof value.memory.content !== "string" || typeof value.memory.scope !== "string" || typeof value.memory.created_at !== "number" || typeof value.memory.updated_at !== "number" || typeof value.memory.is_deleted !== "boolean" || !Number.isSafeInteger(value.version) || value.version < 1 || typeof value.server_updated_at !== "string" || value.score !== void 0 && (typeof value.score !== "number" || !Number.isFinite(value.score))) {
     throw new Error("Invalid nearby private-memory response");
   }
   return value;
@@ -6023,14 +6312,14 @@ function createNearbyRequest(options, apiPath = "/api/private-memories") {
         const body = await response.json().catch(() => null);
         const retryAfter = parseRetryAfterMs(response.headers.get("Retry-After"));
         const error = new RemoteMemoryError(
-          record(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
+          record2(body) && typeof body.detail === "string" ? body.detail : `Nearby request failed (${response.status})`,
           response.status,
-          record(body) && typeof body.code === "string" ? body.code : void 0,
+          record2(body) && typeof body.code === "string" ? body.code : void 0,
           retryAfter ?? void 0,
-          record(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
+          record2(body) && typeof body.rate_limit_bucket === "string" ? body.rate_limit_bucket : void 0
         );
         if (response.status === 429 && retryAfter !== null && retryAfter > 0 && (!error.code || error.code === "rate_limited")) {
-          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
+          const bucket = error.rateLimitBucket && budgets.includes(error.rateLimitBucket) ? error.rateLimitBucket : record2(body) && (body.limit_scope === "account" || body.limit_scope === "ip") && !error.rateLimitBucket ? "*" : route;
           cooldowns.set(bucket, { until: Date.now() + retryAfter, error });
         }
         throw error;
@@ -6053,7 +6342,7 @@ async function createRemoteMemoryPersistence(options) {
     throw new Error("A canonical keyId is required");
   const request = createNearbyRequest(options);
   const account = await request("/account", {}, options.signal);
-  if (!record(account) || account.state !== "active") {
+  if (!record2(account) || account.state !== "active") {
     throw new RemoteMemoryError(
       "Complete and verify migration before using remote memories",
       409,
@@ -6067,6 +6356,25 @@ async function createRemoteMemoryPersistence(options) {
       "key_mismatch"
     );
   }
+  const codec = createTopicCodec(options);
+  let legacyTopicRows = typeof account.legacy_topic_memories === "number" && account.legacy_topic_memories > 0;
+  if (typeof account.legacy_topic_catalog === "number" && account.legacy_topic_catalog > 0)
+    void upgradeLegacyTopicCatalog(request, codec, options.signal).catch((error) => {
+      if (!options.signal?.aborted)
+        getLogger().warn("[memory/remote] Topic catalog upgrade failed:", error);
+    });
+  let legacyCheckedAt = Date.now();
+  let legacyCheck;
+  const recheckLegacyTopicRows = () => {
+    if (legacyCheck || Date.now() - legacyCheckedAt < LEGACY_TOPIC_RECHECK_MS) return;
+    legacyCheckedAt = Date.now();
+    legacyCheck = request("/account", {}, options.signal).then((current) => {
+      if (record2(current) && current.legacy_topic_memories === 0) legacyTopicRows = false;
+    }).catch(() => {
+    }).finally(() => {
+      legacyCheck = void 0;
+    });
+  };
   const snapshots = /* @__PURE__ */ new WeakMap();
   const decode = async (value) => {
     const item = memoryRecord(value);
@@ -6084,6 +6392,9 @@ async function createRemoteMemoryPersistence(options) {
         content: item.memory.is_deleted && item.memory.content === "" ? "" : await decrypt(item.memory.content),
         ...item.memory.kind_value !== void 0 && {
           kind_value: await decrypt(item.memory.kind_value)
+        },
+        ...item.memory.topics !== void 0 && {
+          topics: await codec.decodeTopics(item.memory.topics)
         }
       }
     };
@@ -6095,8 +6406,10 @@ async function createRemoteMemoryPersistence(options) {
       version: item.version,
       content: decoded.memory.content,
       kindValue: decoded.memory.kind_value,
+      topics: decoded.memory.topics,
       encryptedContent: item.memory.content,
-      encryptedKindValue: item.memory.kind_value
+      encryptedKindValue: item.memory.kind_value,
+      encryptedTopics: item.memory.topics
     });
     return decoded;
   };
@@ -6118,7 +6431,7 @@ async function createRemoteMemoryPersistence(options) {
   };
   const decodeCommitted = async (value, write) => {
     const item = memoryRecord(value);
-    if (item.memory.memory_id !== write.body.memory.memory_id || item.memory.content !== write.body.memory.content || item.memory.kind_value !== write.body.memory.kind_value)
+    if (item.memory.memory_id !== write.body.memory.memory_id || item.memory.content !== write.body.memory.content || item.memory.kind_value !== write.body.memory.kind_value || item.memory.topics !== write.body.memory.topics)
       return decode(item);
     return remember(
       {
@@ -6126,7 +6439,8 @@ async function createRemoteMemoryPersistence(options) {
         memory: {
           ...item.memory,
           content: write.content,
-          ...write.kindValue !== void 0 && { kind_value: write.kindValue }
+          ...write.kindValue !== void 0 && { kind_value: write.kindValue },
+          ...write.topics !== void 0 && { topics: write.topics }
         }
       },
       item
@@ -6178,13 +6492,21 @@ async function createRemoteMemoryPersistence(options) {
     const reusableContent = snapshot?.encryptedContent ?? existing?.memory.content;
     const content = reusableContent && (snapshot?.content ?? decoded?.memory.content) === memory.content ? reusableContent : await encryptField2(memory.content);
     const kindValue = memory.kind_value === void 0 ? void 0 : (snapshot?.kindValue ?? decoded?.memory.kind_value) === memory.kind_value ? snapshot?.encryptedKindValue ?? existing.memory.kind_value : await encryptField2(memory.kind_value);
+    const wireTopics2 = snapshot ? snapshot.encryptedTopics : existing?.memory.topics;
+    const topics = memory.topics === void 0 ? void 0 : (snapshot?.topics ?? decoded?.memory.topics) === memory.topics && wireTopics2 !== void 0 && !codec.isLegacy(wireTopics2) ? wireTopics2 : await codec.encodeTopics(memory.topics);
     return {
       body: {
         expected_version: expectedVersion,
-        memory: { ...memory, content, ...kindValue !== void 0 && { kind_value: kindValue } }
+        memory: {
+          ...memory,
+          content,
+          ...kindValue !== void 0 && { kind_value: kindValue },
+          ...topics !== void 0 && { topics }
+        }
       },
       content: memory.content,
-      kindValue: memory.kind_value
+      kindValue: memory.kind_value,
+      topics: memory.topics
     };
   };
   const fetchCandidates = async (embedding2, candidateOptions, withCounts) => {
@@ -6233,32 +6555,72 @@ async function createRemoteMemoryPersistence(options) {
       },
       candidateOptions.signal
     );
-    if (!record(result) || !Array.isArray(result.items))
+    if (!record2(result) || !Array.isArray(result.items))
       throw new Error("Invalid nearby candidate response");
     return result;
   };
   const fetchQueryPage = async (queryOptions) => {
-    const { signal, ...query } = queryOptions;
-    if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
+    const { signal, topics: names, ...wire2 } = queryOptions;
+    if (wire2.limit !== void 0 && (!Number.isInteger(wire2.limit) || wire2.limit < 1 || wire2.limit > 200))
       throw new Error("Page limit must be 1\u2013200");
     for (const [key3, max] of queryListLimits) {
-      const values = query[key3];
+      const values = queryOptions[key3];
       if (values && values.length > max)
         throw new Error(`Query ${key3} accepts at most ${max} entries (got ${values.length})`);
     }
+    const body = wire2;
+    if (names === void 0) return postQuery(body, signal);
+    const hashes = [
+      ...new Set(
+        (await Promise.all(names.map((name) => codec.hash(name)))).filter((h) => h !== null)
+      )
+    ];
+    if (names.length > 0 && hashes.length === 0) return { items: [] };
+    if (hashes.length > 0 && wire2.cursor?.startsWith(LEGACY_TOPIC_CURSOR)) {
+      const page2 = await postQuery(
+        {
+          ...wire2,
+          cursor: wire2.cursor.slice(LEGACY_TOPIC_CURSOR.length) || void 0,
+          topics_legacy: true
+        },
+        signal
+      );
+      const wanted = new Set(names.map(normalizeTopicName));
+      const hashed2 = new Set(hashes);
+      const matches = await Promise.all(
+        page2.items.map(
+          (item) => codec.matchesLegacy(
+            record2(item) && record2(item.memory) ? item.memory.topics : void 0,
+            wanted,
+            hashed2
+          )
+        )
+      );
+      return {
+        ...page2,
+        items: page2.items.filter((_, i) => matches[i]),
+        next_cursor: page2.next_cursor === void 0 ? void 0 : LEGACY_TOPIC_CURSOR + page2.next_cursor
+      };
+    }
+    const page = await postQuery({ ...body, topic_hashes: hashes }, signal);
+    if (hashes.length === 0 || page.next_cursor !== void 0 || !legacyTopicRows) return page;
+    recheckLegacyTopicRows();
+    return { ...page, next_cursor: LEGACY_TOPIC_CURSOR };
+  };
+  const postQuery = async (body, signal) => {
     const page = await request(
       "/memories/query",
       {
         method: "POST",
         body: JSON.stringify(
           Object.fromEntries(
-            queryFields.filter((key3) => query[key3] !== void 0).map((key3) => [key3, query[key3]])
+            queryFields.filter((key3) => body[key3] !== void 0).map((key3) => [key3, body[key3]])
           )
         )
       },
       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")
+    if (!record2(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 page;
   };
@@ -6272,13 +6634,13 @@ async function createRemoteMemoryPersistence(options) {
       unavailable_count: result.unavailable_count
     };
   };
-  return {
-    ...createRemoteTopicPersistence(request),
+  const persistence = {
+    ...createRemoteTopicPersistence(request, codec),
     ...createRemoteWorkPersistence(request),
     supportsRealtimeChanges: account.realtime_changes === true,
     counts: async () => {
       const result = await request("/counts", {});
-      if (!record(result) || ["live", "archived", "quarantined"].some(
+      if (!record2(result) || ["live", "archived", "quarantined"].some(
         (key3) => !Number.isSafeInteger(result[key3]) || result[key3] < 0
       ))
         throw new Error("Invalid nearby memory counts");
@@ -6295,8 +6657,8 @@ async function createRemoteMemoryPersistence(options) {
         method: "POST",
         body: JSON.stringify({ ...window2, limit })
       });
-      if (!record(result) || !Array.isArray(result.items) || result.items.some(
-        (item) => !record(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
+      if (!record2(result) || !Array.isArray(result.items) || result.items.some(
+        (item) => !record2(item) || typeof item.memory_id !== "string" || !item.memory_id || typeof item.score !== "number" || !Number.isFinite(item.score) || item.score <= 0 || item.score > 1
       ))
         throw new Error("Invalid nearby temporal candidates");
       return result.items.map((item) => item.memory_id);
@@ -6327,7 +6689,7 @@ async function createRemoteMemoryPersistence(options) {
         if (query[key3] !== void 0) params.set(key3, String(query[key3]));
       }
       const page = await request("/memories?" + params.toString(), {}, signal);
-      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
+      if (!record2(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string") {
         throw new Error("Invalid nearby private-memory page");
       }
       return {
@@ -6367,7 +6729,7 @@ async function createRemoteMemoryPersistence(options) {
         },
         signal
       );
-      if (!record(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
+      if (!record2(result) || !Array.isArray(result.items) || result.items.length !== prepared.length)
         throw new Error("Invalid nearby batch response");
       return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
     },
@@ -6382,20 +6744,87 @@ async function createRemoteMemoryPersistence(options) {
     queryMetadata: async (queryOptions = {}) => {
       const page = await fetchQueryPage(queryOptions);
       return {
-        items: page.items.map((item) => {
-          const {
-            memory: { content: _content, kind_value: _kindValue, ...memory },
-            version,
-            server_updated_at
-          } = memoryRecord(item);
-          return { memory, version, server_updated_at };
-        }),
+        items: await Promise.all(
+          page.items.map(async (item) => {
+            const {
+              memory: { content: _content, kind_value: _kindValue, topics, ...memory },
+              version,
+              server_updated_at
+            } = memoryRecord(item);
+            const plain2 = topics === void 0 ? void 0 : await codec.decodeTopics(topics).catch(() => null);
+            return {
+              memory: { ...memory, ...typeof plain2 === "string" && { topics: plain2 } },
+              version,
+              server_updated_at
+            };
+          })
+        ),
         ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor }
       };
     },
     candidateSet,
     candidates: async (embedding2, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding2, candidateOptions, false)).items)
   };
+  let rejectedRows = 0;
+  const rewriteLegacyTopics = async (records, token) => {
+    const write = (batch) => persistence.putMany(
+      batch.map((item) => ({ memory: item.memory, expectedVersion: item })),
+      options.signal,
+      token
+    );
+    try {
+      await write(records);
+      return true;
+    } catch (error) {
+      if (!isVersionConflict(error) && !isRejectedRow(error)) throw error;
+      if (records.length === 1) {
+        if (isRejectedRow(error)) rejectedRows++;
+        return false;
+      }
+      let complete = true;
+      for (const item of records)
+        await write([item]).catch((rowError) => {
+          if (isRejectedRow(rowError)) rejectedRows++;
+          else if (!isVersionConflict(rowError)) throw rowError;
+          complete = false;
+        });
+      return complete;
+    }
+  };
+  const upgradeLegacyTopics = () => withRemoteWorkLease(persistence, "topics", TOPIC_UPGRADE_PROCESSOR, async (token, lease) => {
+    let cursor;
+    let complete = true;
+    do {
+      options.signal?.throwIfAborted();
+      if (lease.aborted) return false;
+      const page = await fetchQueryPage({
+        topics_legacy: true,
+        include_archived: true,
+        include_quarantined: true,
+        include_superseded: true,
+        limit: TOPIC_UPGRADE_PAGE,
+        ...cursor !== void 0 && { cursor },
+        signal: options.signal
+      });
+      const { items } = await decodeAll(page.items);
+      const legacy = items.filter((item) => codec.isLegacy(snapshots.get(item)?.encryptedTopics));
+      if (legacy.length && !await rewriteLegacyTopics(legacy, token)) complete = false;
+      cursor = page.next_cursor;
+    } while (cursor);
+    if (rejectedRows)
+      getLogger().warn(
+        `[memory/remote] Nearby rejected ${rejectedRows} rows during the topic upgrade; they keep legacy topics`
+      );
+    return complete;
+  });
+  if (legacyTopicRows)
+    void upgradeLegacyTopics().then((complete) => {
+      if (complete) legacyTopicRows = false;
+    }).catch((error) => {
+      if (!options.signal?.aborted)
+        getLogger().warn("[memory/remote] Topic upgrade failed:", error);
+    });
+  return persistence;
 }
 
 // src/lib/chat/inbox.ts
@@ -6946,9 +7375,9 @@ function toResponsesFormat(tool) {
 function getCachedServerTools() {
   if (typeof localStorage === "undefined") return null;
   try {
-    const cached = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
-    if (!cached) return null;
-    const parsed = JSON.parse(cached);
+    const cached2 = localStorage.getItem(SERVER_TOOLS_CACHE_KEY);
+    if (!cached2) return null;
+    const parsed = JSON.parse(cached2);
     if (parsed.version !== CACHE_VERSION) {
       removeLocalStorageCache();
       return null;
@@ -6992,8 +7421,8 @@ function clearServerToolsCache(cache = localStorageToolsCache) {
   return cache.clear?.();
 }
 function getToolsChecksum2(cache = localStorageToolsCache) {
-  const cached = cache.get();
-  return cached instanceof Promise ? cached.then((c) => c?.checksum) : cached?.checksum;
+  const cached2 = cache.get();
+  return cached2 instanceof Promise ? cached2.then((c) => c?.checksum) : cached2?.checksum;
 }
 function shouldRefreshTools(responseChecksum, cache = localStorageToolsCache) {
   if (!responseChecksum) {
@@ -7056,33 +7485,33 @@ async function getServerTools(options) {
   } catch (error) {
     getLogger().warn("[serverTools] Cache read failed; falling through to server fetch:", error);
   }
-  const cached = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
-  const cacheValid = !isCacheExpired(cached, cacheExpirationMs);
-  if (cached && cacheValid && !forceRefresh) {
-    return cached.tools;
+  const cached2 = rawCached && rawCached.version === CACHE_VERSION ? rawCached : null;
+  const cacheValid = !isCacheExpired(cached2, cacheExpirationMs);
+  if (cached2 && cacheValid && !forceRefresh) {
+    return cached2.tools;
   }
   try {
     const { BASE_URL: BASE_URL2 } = await import("./clientConfig-VPOGQRNP.mjs");
     const effectiveBaseUrl = baseUrl ?? BASE_URL2;
-    const validator = cached && !forceRefresh ? cached.etag : void 0;
+    const validator = cached2 && !forceRefresh ? cached2.etag : void 0;
     let authHeaders;
     if (apiKey) {
       authHeaders = { "X-API-Key": apiKey };
     } else {
       if (!getToken) {
         getLogger().warn("[serverTools] No auth method available for fetching tools");
-        return cached?.tools ?? [];
+        return cached2?.tools ?? [];
       }
       const token = await getToken();
       if (!token) {
         getLogger().warn("[serverTools] No auth token available for fetching tools");
-        return cached?.tools ?? [];
+        return cached2?.tools ?? [];
       }
       authHeaders = { Authorization: `Bearer ${token}` };
     }
     const result = await fetchServerToolsFromApi(effectiveBaseUrl, authHeaders, validator);
     if (result.notModified) {
-      const confirmed = cached;
+      const confirmed = cached2;
       await persistCache({ ...confirmed, timestamp: Date.now() });
       return confirmed.tools;
     }
@@ -7090,9 +7519,9 @@ async function getServerTools(options) {
     return result.tools;
   } catch (error) {
     getLogger().error("[serverTools] Failed to fetch server tools:", error);
-    if (cached?.tools) {
+    if (cached2?.tools) {
       getLogger().warn("[serverTools] Using stale cached tools due to fetch error");
-      return cached.tools;
+      return cached2.tools;
     }
     return [];
   }
@@ -8226,13 +8655,13 @@ function extractParamGroups(content) {
 }
 function mergeXaiInlineParameterTags(content, toolCalls) {
   if (!content || !content.includes(PARAM_MARKER)) return content;
-  const entries = Array.from(toolCalls.values());
-  if (entries.length === 0) return content;
+  const entries2 = Array.from(toolCalls.values());
+  if (entries2.length === 0) return content;
   const groups = extractParamGroups(content);
   if (groups.length === 0) return content;
-  const pairCount = Math.min(groups.length, entries.length);
+  const pairCount = Math.min(groups.length, entries2.length);
   for (let i = 0; i < pairCount; i++) {
-    const target = entries[i];
+    const target = entries2[i];
     const params = groups[i];
     if (!target || !params) continue;
     let args = {};
@@ -11554,21 +11983,21 @@ function contextFields(context) {
   );
 }
 function conversationContext(data) {
-  const entries = Object.entries(data).filter(([field10]) => field10.startsWith(CONTEXT_FIELD_PREFIX)).map(([field10, value]) => [field10.slice(CONTEXT_FIELD_PREFIX.length), value]);
-  return entries.length > 0 ? plain(Object.fromEntries(entries)) : void 0;
+  const entries2 = Object.entries(data).filter(([field10]) => field10.startsWith(CONTEXT_FIELD_PREFIX)).map(([field10, value]) => [field10.slice(CONTEXT_FIELD_PREFIX.length), value]);
+  return entries2.length > 0 ? plain(Object.fromEntries(entries2)) : void 0;
 }
-function toConversation(record2) {
-  const pinnedAt = number(record2.data.pinnedAt);
-  const projectId = text3(record2.data.projectId);
-  const context = conversationContext(record2.data);
+function toConversation(record3) {
+  const pinnedAt = number(record3.data.pinnedAt);
+  const projectId = text3(record3.data.projectId);
+  const context = conversationContext(record3.data);
   return {
-    uniqueId: record2.id,
-    conversationId: record2.id,
-    title: text3(record2.data.title) ?? "",
+    uniqueId: record3.id,
+    conversationId: record3.id,
+    title: text3(record3.data.title) ?? "",
     ...projectId ? { projectId } : {},
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt),
-    isDeleted: record2.isDeleted,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt),
+    isDeleted: record3.isDeleted,
     pinnedAt: pinnedAt ? new Date(pinnedAt) : null,
     ...context ? { context } : {}
   };
@@ -11590,21 +12019,21 @@ function messageData(options) {
     ...anuma ? { anuma } : {}
   });
 }
-function toMessage(record2) {
-  const { chunkOffsets: _offsets, truncated: _truncated, anuma: rawAnuma, ...fields } = record2.data;
+function toMessage(record3) {
+  const { chunkOffsets: _offsets, truncated: _truncated, anuma: rawAnuma, ...fields } = record3.data;
   const anuma = readAnumaTurn(rawAnuma);
   return {
     ...anuma ? { anuma } : {},
     ...fields,
-    uniqueId: record2.id,
-    messageId: record2.sortKey,
-    conversationId: record2.conversationId,
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt)
+    uniqueId: record3.id,
+    messageId: record3.sortKey,
+    conversationId: record3.conversationId,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt)
   };
 }
-function chunkOffsets(record2) {
-  const offsets = record2.data.chunkOffsets;
+function chunkOffsets(record3) {
+  const offsets = record3.data.chunkOffsets;
   return Array.isArray(offsets) ? offsets : void 0;
 }
 function toSkeletons(records) {
@@ -11625,15 +12054,15 @@ function toSkeletons(records) {
     };
   });
 }
-function toSummary(record2) {
+function toSummary(record3) {
   return {
-    uniqueId: record2.id,
-    conversationId: record2.id,
-    summary: text3(record2.data.summary) ?? "",
-    summarizedUpTo: text3(record2.data.summarizedUpTo) ?? "",
-    tokenCount: number(record2.data.tokenCount) ?? 0,
-    createdAt: new Date(record2.createdAt),
-    updatedAt: new Date(record2.updatedAt)
+    uniqueId: record3.id,
+    conversationId: record3.id,
+    summary: text3(record3.data.summary) ?? "",
+    summarizedUpTo: text3(record3.data.summarizedUpTo) ?? "",
+    tokenCount: number(record3.data.tokenCount) ?? 0,
+    createdAt: new Date(record3.createdAt),
+    updatedAt: new Date(record3.updatedAt)
   };
 }
 function links(data) {
@@ -11659,10 +12088,10 @@ function applyLinkOps(data, ops) {
   }
   return plain({ links: current });
 }
-function toLinks(record2) {
-  return links(record2.data).map((l) => ({
-    uniqueId: `${record2.id}:${l.memoryId}`,
-    conversationId: record2.id,
+function toLinks(record3) {
+  return links(record3.data).map((l) => ({
+    uniqueId: `${record3.id}:${l.memoryId}`,
+    conversationId: record3.id,
     memoryId: l.memoryId,
     score: l.score,
     createdAt: new Date(l.createdAt)
@@ -11671,24 +12100,24 @@ function toLinks(record2) {
 function bytes(value) {
   return new TextEncoder().encode(JSON.stringify(value)).length;
 }
-function fitRecord(record2) {
-  if (record2.kind !== "message" || bytes(record2) <= recordBudgetBytes) return record2;
-  const data = { ...record2.data };
+function fitRecord(record3) {
+  if (record3.kind !== "message" || bytes(record3) <= recordBudgetBytes) return record3;
+  const data = { ...record3.data };
   const truncated = [];
   for (const field10 of droppable) {
-    if (bytes({ ...record2, data }) <= recordBudgetBytes) break;
+    if (bytes({ ...record3, data }) <= recordBudgetBytes) break;
     if (data[field10] === void 0) continue;
     delete data[field10];
     truncated.push(field10);
   }
   const content = text3(data.content) ?? "";
-  const over = bytes({ ...record2, data }) - recordBudgetBytes;
+  const over = bytes({ ...record3, data }) - recordBudgetBytes;
   if (over > 0) {
     const encoded = new TextEncoder().encode(content);
     data.content = new TextDecoder().decode(encoded.slice(0, Math.max(0, encoded.length - over - 64))).replace(/�$/, "");
     truncated.push("content");
   }
-  return { ...record2, data: { ...data, truncated } };
+  return { ...record3, data: { ...data, truncated } };
 }
 function acceptedVector(vector2) {
   if (!vector2 || !acceptedDims.has(vector2.length)) return void 0;
@@ -11732,8 +12161,8 @@ function anumaTurnContent(bubbles) {
   return bubbles.join("\n\n");
 }
 function anumaLastReadSortKey(conversation) {
-  const record2 = conversation && "record" in conversation ? conversation.record : conversation;
-  const state = record2?.data.anuma;
+  const record3 = conversation && "record" in conversation ? conversation.record : conversation;
+  const state = record3?.data.anuma;
   if (!isObject(state)) return 0;
   const sortKey = state.lastReadSortKey;
   return Number.isSafeInteger(sortKey) && sortKey > 0 ? sortKey : 0;
@@ -11786,19 +12215,19 @@ async function markAnumaRead(store, sortKey, options = {}) {
     const current = await ensureAnumaConversation(store, options);
     const read = anumaLastReadSortKey(current);
     if (sortKey <= read) return current;
-    const record2 = current.record;
-    const state = isObject(record2.data.anuma) ? record2.data.anuma : {};
-    const data = plain({ ...record2.data, anuma: { ...state, lastReadSortKey: sortKey } });
+    const record3 = current.record;
+    const state = isObject(record3.data.anuma) ? record3.data.anuma : {};
+    const data = plain({ ...record3.data, anuma: { ...state, lastReadSortKey: sortKey } });
     try {
       const [written] = await store.putMany(
         [
           {
             expectedVersion: current.version,
             record: {
-              ...record2,
+              ...record3,
               data,
-              sortKey: conversationSortKey(data, record2.createdAt),
-              updatedAt: Math.max(record2.updatedAt, now())
+              sortKey: conversationSortKey(data, record3.createdAt),
+              updatedAt: Math.max(record3.updatedAt, now())
             }
           }
         ],
@@ -11833,22 +12262,22 @@ function createSummaryContext(database, encryption = {}) {
     summariesCollection: database.get("conversation_summaries")
   };
 }
-function modelToStored(record2, summary) {
+function modelToStored(record3, summary) {
   return {
-    uniqueId: record2.id,
-    conversationId: record2.conversationId,
+    uniqueId: record3.id,
+    conversationId: record3.conversationId,
     summary,
-    summarizedUpTo: record2.summarizedUpTo,
-    tokenCount: record2.tokenCount,
-    createdAt: record2.createdAt,
-    updatedAt: record2.updatedAt
+    summarizedUpTo: record3.summarizedUpTo,
+    tokenCount: record3.tokenCount,
+    createdAt: record3.createdAt,
+    updatedAt: record3.updatedAt
   };
 }
 async function getConversationSummaryOp(ctx, conversationId) {
   const results = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
   if (results.length === 0) return null;
-  const record2 = results[0];
-  const stored2 = modelToStored(record2, record2.summary);
+  const record3 = results[0];
+  const stored2 = modelToStored(record3, record3.summary);
   if (ctx.walletAddress && isEncrypted(stored2.summary)) {
     if (ctx.signMessage) {
       try {
@@ -11867,7 +12296,7 @@ async function getConversationSummaryOp(ctx, conversationId) {
         ctx.embeddedWalletSigner
       );
       await ctx.database.write(async () => {
-        const current = await ctx.summariesCollection.query(Q4.where("id", record2.id)).fetch();
+        const current = await ctx.summariesCollection.query(Q4.where("id", record3.id)).fetch();
         if (current[0]?.summary === stored2.summary) {
           await current[0].update((rec) => {
             rec.summary = encryptedSummary;
@@ -11882,19 +12311,19 @@ async function getConversationSummaryOp(ctx, conversationId) {
 }
 async function upsertConversationSummaryOp(ctx, conversationId, summary, summarizedUpTo, tokenCount) {
   const revision2 = getConversationRevision(ctx.database, conversationId);
-  let record2;
+  let record3;
   const encryptedSummary = ctx.walletAddress ? await encryptField(summary, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner) : summary;
   await ctx.database.write(async () => {
     assertConversationRevision(ctx.database, conversationId, revision2);
     const existing = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
     if (existing.length > 0) {
-      record2 = await existing[0].update((rec) => {
+      record3 = await existing[0].update((rec) => {
         rec.summary = encryptedSummary;
         rec.summarizedUpTo = summarizedUpTo;
         rec.tokenCount = tokenCount;
       });
     } else {
-      record2 = await ctx.summariesCollection.create((rec) => {
+      record3 = await ctx.summariesCollection.create((rec) => {
         rec.conversationId = conversationId;
         rec.summary = encryptedSummary;
         rec.summarizedUpTo = summarizedUpTo;
@@ -11902,13 +12331,13 @@ async function upsertConversationSummaryOp(ctx, conversationId, summary, summari
       });
     }
   });
-  return modelToStored(record2, summary);
+  return modelToStored(record3, summary);
 }
 async function deleteConversationSummaryOp(ctx, conversationId) {
   await ctx.database.write(async () => {
     const existing = await ctx.summariesCollection.query(Q4.where("conversation_id", conversationId)).fetch();
-    for (const record2 of existing) {
-      await record2.destroyPermanently();
+    for (const record3 of existing) {
+      await record3.destroyPermanently();
     }
   });
 }
@@ -11984,7 +12413,7 @@ function messageRecord(message) {
   const fitted = chunks3?.length ? fitChunks(chunks3) : void 0;
   const single = fitted ? void 0 : acceptedVector(vector2);
   const embeddings2 = fitted?.map((c) => c.vector) ?? (single ? [single] : void 0);
-  const record2 = fitRecord({
+  const record3 = fitRecord({
     kind: "message",
     id: message.uniqueId,
     conversationId: message.conversationId,
@@ -11998,7 +12427,7 @@ function messageRecord(message) {
     }
   });
   return {
-    record: record2,
+    record: record3,
     ...embeddings2 ? { embeddings: embeddings2 } : {},
     ...embeddings2 && message.embeddingModel ? { embeddingModel: message.embeddingModel } : {}
   };
@@ -12146,15 +12575,15 @@ function ref(value) {
 function sameMetadata(a, b) {
   return metadata.every((key3) => a[key3] === b[key3]);
 }
-function wire(record2, payload) {
+function wire(record3, payload) {
   return {
-    kind: record2.kind,
-    id: record2.id,
-    conversation_id: record2.conversationId,
-    sort_key: record2.sortKey,
-    created_at: record2.createdAt,
-    updated_at: record2.updatedAt,
-    is_deleted: record2.isDeleted,
+    kind: record3.kind,
+    id: record3.id,
+    conversation_id: record3.conversationId,
+    sort_key: record3.sortKey,
+    created_at: record3.createdAt,
+    updated_at: record3.updatedAt,
+    is_deleted: record3.isDeleted,
     payload
   };
 }
@@ -12211,10 +12640,10 @@ async function createRemoteChatStore(options) {
       serverUpdatedAt: value.server_updated_at
     };
   };
-  const seal = async (record2, signal) => {
-    if (record2.isDeleted) return "";
+  const seal = async (record3, signal) => {
+    if (record3.isDeleted) return "";
     const payload = await encrypt(
-      JSON.stringify({ schema: 1, account_id: accountId, key_id: keyId, record: record2 })
+      JSON.stringify({ schema: 1, account_id: accountId, key_id: keyId, record: record3 })
     );
     signal?.throwIfAborted();
     if (!cipherPattern.test(payload) || payload.length > maxPayload) invalid();
@@ -12578,8 +13007,8 @@ var emptyMessage = {
 var maxPasses = 5;
 var verifyBatch = 1e3;
 var writeBatch = 25;
-function key(record2) {
-  return `${record2.kind}/${record2.id}`;
+function key(record3) {
+  return `${record3.kind}/${record3.id}`;
 }
 function sealed(value) {
   if (typeof value === "string") return isEncrypted(value);
@@ -12708,11 +13137,11 @@ async function missing(store, records, signal) {
   const out = /* @__PURE__ */ new Set();
   for (let i = 0; i < records.length; i += verifyBatch) {
     const refs = await store.verify(
-      records.slice(i, i + verifyBatch).map(({ record: record2 }) => ({
-        kind: record2.kind,
-        id: record2.id,
-        updatedAt: record2.updatedAt,
-        isDeleted: record2.isDeleted
+      records.slice(i, i + verifyBatch).map(({ record: record3 }) => ({
+        kind: record3.kind,
+        id: record3.id,
+        updatedAt: record3.updatedAt,
+        isDeleted: record3.isDeleted
       })),
       signal
     );
@@ -12752,14 +13181,14 @@ async function deletedSinceUpload(store, journal, local, signal) {
   const live2 = (await store.getMany(gone.map(ref2), signal)).filter((s) => !s.record.isDeleted);
   const tombstoning = new Set(live2.map((s) => key(s.record)));
   await journal.drop(gone.filter((k) => !tombstoning.has(k)));
-  return live2.map(({ record: record2, version }) => {
-    const empty = emptied[record2.kind];
+  return live2.map(({ record: record3, version }) => {
+    const empty = emptied[record3.kind];
     return {
       record: {
-        ...record2,
+        ...record3,
         isDeleted: !empty,
         data: empty ?? {},
-        updatedAt: Math.max(Date.now(), record2.updatedAt + 1)
+        updatedAt: Math.max(Date.now(), record3.updatedAt + 1)
       },
       expectedVersion: version
     };
@@ -13108,8 +13537,8 @@ function createVaultAttachments(options) {
     },
     async read(attachmentId, signal) {
       if (!attachmentIdPattern2.test(attachmentId)) invalidAttachment();
-      const cached = await cache?.get(attachmentId).catch(() => null);
-      if (cached) return cached;
+      const cached2 = await cache?.get(attachmentId).catch(() => null);
+      if (cached2) return cached2;
       for (let attempt = 0; ; attempt++) {
         const found = await withRetry(() => store.attachments.get(attachmentId, signal), signal);
         if (!found?.download) return null;
@@ -13138,8 +13567,8 @@ function validRef(value) {
   const ref3 = value;
   return typeof ref3.attachmentId === "string" && attachmentIdPattern2.test(ref3.attachmentId) && typeof ref3.fileId === "string" && ref3.fileId.length > 0 && typeof ref3.name === "string" && typeof ref3.type === "string" && Number.isSafeInteger(ref3.size) && ref3.size >= 0;
 }
-function vaultAttachmentRefs(record2) {
-  const refs = record2.data.vaultAttachments;
+function vaultAttachmentRefs(record3) {
+  const refs = record3.data.vaultAttachments;
   return Array.isArray(refs) ? refs.filter(validRef) : [];
 }
 function journalKey(messageId, fileId) {
@@ -13347,14 +13776,14 @@ function sameRecord(a, b) {
   return a.sortKey === b.sortKey && a.isDeleted === b.isDeleted && sameJson(a.data, b.data);
 }
 function toWrite(base, patch) {
-  const record2 = applyPatch(base?.record, patch);
-  if (!record2) return void 0;
-  if (base && patch.embeddings === void 0 && sameRecord(base.record, record2)) return null;
+  const record3 = applyPatch(base?.record, patch);
+  if (!record3) return void 0;
+  if (base && patch.embeddings === void 0 && sameRecord(base.record, record3)) return null;
   return {
-    record: fitRecord(record2),
+    record: fitRecord(record3),
     expectedVersion: base?.version ?? 0,
-    ...patch.embeddings !== void 0 && !record2.isDeleted ? { embeddings: patch.embeddings } : {},
-    ...patch.embeddingModel !== void 0 && !record2.isDeleted ? { embeddingModel: patch.embeddingModel } : {}
+    ...patch.embeddings !== void 0 && !record3.isDeleted ? { embeddings: patch.embeddings } : {},
+    ...patch.embeddingModel !== void 0 && !record3.isDeleted ? { embeddingModel: patch.embeddingModel } : {}
   };
 }
 var maxWrites = 25;
@@ -13488,11 +13917,11 @@ function createVaultChatBackend(options) {
     for (const listener of [...listeners]) listener(event);
   };
   const view = (k) => {
-    let record2 = confirmed.get(k)?.record;
+    let record3 = confirmed.get(k)?.record;
     for (const patch of [inflight.get(k), pending.get(k)]) {
-      if (patch) record2 = applyPatch(record2, patch) ?? record2;
+      if (patch) record3 = applyPatch(record3, patch) ?? record3;
     }
-    return record2;
+    return record3;
   };
   const conversationLive = (conversationId) => {
     const conversation2 = view(key2("conversation", conversationId));
@@ -13503,10 +13932,10 @@ function createVaultChatBackend(options) {
     const out = [];
     for (const k of keys) {
       if (!k.startsWith(`${kind}/`)) continue;
-      const record2 = view(k);
-      if (!record2 || record2.isDeleted && !includeDeleted) continue;
-      if (conversationId !== void 0 && record2.conversationId !== conversationId) continue;
-      out.push(record2);
+      const record3 = view(k);
+      if (!record3 || record3.isDeleted && !includeDeleted) continue;
+      if (conversationId !== void 0 && record3.conversationId !== conversationId) continue;
+      out.push(record3);
     }
     return out;
   };
@@ -13517,7 +13946,7 @@ function createVaultChatBackend(options) {
       account: cache.account,
       cursor: cursor ?? "",
       records: [...confirmed.values()].filter(
-        ({ record: record2 }) => record2.kind === "conversation" || record2.kind !== "project" && keep.has(record2.conversationId)
+        ({ record: record3 }) => record3.kind === "conversation" || record3.kind !== "project" && keep.has(record3.conversationId)
       ),
       threads: kept,
       absent: [...checked].filter((k) => {
@@ -13831,17 +14260,17 @@ function createVaultChatBackend(options) {
     return loading;
   };
   const applyRemote = (snapshot) => {
-    const { record: record2 } = snapshot;
-    const k = key2(record2.kind, record2.id);
-    if (record2.kind === "conversation") {
+    const { record: record3 } = snapshot;
+    const k = key2(record3.kind, record3.id);
+    if (record3.kind === "conversation") {
       if (!merge(snapshot)) return;
-      if (record2.isDeleted) forgetConversation(record2.id);
-      announce([record2]);
+      if (record3.isDeleted) forgetConversation(record3.id);
+      announce([record3]);
       return;
     }
-    if (record2.kind === "project") return;
-    const relevant2 = threads.has(record2.conversationId) || confirmed.has(k) || checked.has(k) && record2.kind !== "message";
-    if (relevant2 && merge(snapshot)) announce([record2]);
+    if (record3.kind === "project") return;
+    const relevant2 = threads.has(record3.conversationId) || confirmed.has(k) || checked.has(k) && record3.kind !== "message";
+    if (relevant2 && merge(snapshot)) announce([record3]);
   };
   const listIndex = async (source) => {
     const index = [];
@@ -13992,8 +14421,8 @@ function createVaultChatBackend(options) {
       checked.add(k);
       if (found) merge(found);
     }
-    const record2 = view(k);
-    return record2 && !record2.isDeleted && conversationLive(record2.conversationId) ? record2 : void 0;
+    const record3 = view(k);
+    return record3 && !record3.isDeleted && conversationLive(record3.conversationId) ? record3 : void 0;
   };
   const child = async (kind, conversationId) => {
     await available2();
@@ -14030,19 +14459,19 @@ function createVaultChatBackend(options) {
     await backend.deleteSummary(conversationId);
   };
   const storedMessage = async (uniqueId) => {
-    const record2 = await message(uniqueId);
-    return record2 ? toMessage(record2) : null;
+    const record3 = await message(uniqueId);
+    return record3 ? toMessage(record3) : null;
   };
   const patchMessage = async (uniqueId, patch) => {
-    const record2 = await message(uniqueId);
-    if (!record2) return null;
+    const record3 = await message(uniqueId);
+    if (!record3) return null;
     await enqueue({
       kind: "message",
       id: uniqueId,
-      conversationId: record2.conversationId,
+      conversationId: record3.conversationId,
       ...patch
     });
-    emit({ type: "messages", conversationId: record2.conversationId, origin: "local" });
+    emit({ type: "messages", conversationId: record3.conversationId, origin: "local" });
     const updated = view(key2("message", uniqueId));
     return updated && !updated.isDeleted ? toMessage(updated) : null;
   };
@@ -14067,12 +14496,12 @@ function createVaultChatBackend(options) {
   });
   const backend = {
     async getConversation(conversationId) {
-      const record2 = await conversation(conversationId);
-      return record2 && !record2.isDeleted ? toConversation(record2) : null;
+      const record3 = await conversation(conversationId);
+      return record3 && !record3.isDeleted ? toConversation(record3) : null;
     },
     async getConversations(query) {
       await available2();
-      return all("conversation").filter((record2) => record2.id !== ANUMA_CONVERSATION_ID).map(toConversation).filter(
+      return all("conversation").filter((record3) => record3.id !== ANUMA_CONVERSATION_ID).map(toConversation).filter(
         (c) => query?.projectId === void 0 || (query.projectId === null ? !c.projectId : c.projectId === query.projectId)
       ).sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
@@ -14111,13 +14540,13 @@ function createVaultChatBackend(options) {
     async updateConversationContext(conversationId, context) {
       const set = contextFields(context);
       if (Object.keys(set).length > 0) return updateConversation(conversationId, set);
-      const record2 = await conversation(conversationId);
-      return !!record2 && !record2.isDeleted;
+      const record3 = await conversation(conversationId);
+      return !!record3 && !record3.isDeleted;
     },
     async deleteConversation(conversationId) {
       if (conversationId === ANUMA_CONVERSATION_ID) return false;
-      const record2 = await conversation(conversationId);
-      if (!record2 || record2.isDeleted) return false;
+      const record3 = await conversation(conversationId);
+      if (!record3 || record3.isDeleted) return false;
       for (const [k, patch] of pending)
         if (patch.conversationId === conversationId) pending.delete(k);
       await enqueue({ kind: "conversation", id: conversationId, conversationId: "", delete: true });
@@ -14153,8 +14582,8 @@ function createVaultChatBackend(options) {
       const unknown = ids.map((id2) => key2("message", id2)).filter((k) => !view(k) && !checked.has(k));
       await refresh(unknown);
       return ids.flatMap((id2) => {
-        const record2 = view(key2("message", id2));
-        return record2 && !record2.isDeleted && conversationLive(record2.conversationId) ? [toMessage(record2)] : [];
+        const record3 = view(key2("message", id2));
+        return record3 && !record3.isDeleted && conversationLive(record3.conversationId) ? [toMessage(record3)] : [];
       });
     },
     async getMessageCount(conversationId) {
@@ -14162,8 +14591,8 @@ function createVaultChatBackend(options) {
     },
     async getToolCallEventIds(conversationId) {
       const ids = /* @__PURE__ */ new Set();
-      for (const record2 of await thread(conversationId)) {
-        const events = record2.data.toolCallEvents;
+      for (const record3 of await thread(conversationId)) {
+        const events = record3.data.toolCallEvents;
         if (!Array.isArray(events)) continue;
         for (const event of events)
           if (event && typeof event === "object" && !Array.isArray(event) && typeof event.id === "string")
@@ -14256,21 +14685,21 @@ function createVaultChatBackend(options) {
     },
     async clearMessages(conversationId) {
       await invalidateSummary(conversationId);
-      for (const record2 of await thread(conversationId))
-        await enqueue({ kind: "message", id: record2.id, conversationId, delete: true });
+      for (const record3 of await thread(conversationId))
+        await enqueue({ kind: "message", id: record3.id, conversationId, delete: true });
       emit({ type: "messages", conversationId, origin: "local" });
     },
     async deleteMessage(uniqueId) {
-      const record2 = await message(uniqueId);
-      if (!record2) return null;
-      await invalidateSummary(record2.conversationId, record2);
+      const record3 = await message(uniqueId);
+      if (!record3) return null;
+      await invalidateSummary(record3.conversationId, record3);
       await enqueue({
         kind: "message",
         id: uniqueId,
-        conversationId: record2.conversationId,
+        conversationId: record3.conversationId,
         delete: true
       });
-      emit({ type: "messages", conversationId: record2.conversationId, origin: "local" });
+      emit({ type: "messages", conversationId: record3.conversationId, origin: "local" });
       return uniqueId;
     },
     observeMessages(conversationId) {
@@ -14283,13 +14712,13 @@ function createVaultChatBackend(options) {
       await available2();
       if (query?.conversationId) await loadThread(query.conversationId);
       const files = [];
-      for (const record2 of all("message", query?.conversationId)) {
-        if (!conversationLive(record2.conversationId)) continue;
-        const stored2 = toMessage(record2);
+      for (const record3 of all("message", query?.conversationId)) {
+        if (!conversationLive(record3.conversationId)) continue;
+        const stored2 = toMessage(record3);
         for (const file of stored2.files ?? [])
           files.push({
             ...file,
-            conversationId: record2.conversationId,
+            conversationId: record3.conversationId,
             createdAt: stored2.createdAt,
             messageRole: stored2.role
           });
@@ -14328,8 +14757,8 @@ function createVaultChatBackend(options) {
       return results;
     },
     async getSummary(conversationId) {
-      const record2 = await child("summary", conversationId);
-      return record2 && !record2.isDeleted && record2.data.summarizedUpTo ? toSummary(record2) : null;
+      const record3 = await child("summary", conversationId);
+      return record3 && !record3.isDeleted && record3.data.summarizedUpTo ? toSummary(record3) : null;
     },
     async upsertSummary(conversationId, summary, summarizedUpTo, tokenCount) {
       await child("summary", conversationId);
@@ -14345,8 +14774,8 @@ function createVaultChatBackend(options) {
       return toSummary(view(key2("summary", conversationId)));
     },
     async deleteSummary(conversationId) {
-      const record2 = await child("summary", conversationId);
-      if (!record2 || record2.isDeleted) return;
+      const record3 = await child("summary", conversationId);
+      if (!record3 || record3.isDeleted) return;
       await enqueue({
         kind: "summary",
         id: conversationId,
@@ -14356,8 +14785,8 @@ function createVaultChatBackend(options) {
       emit({ type: "summary", conversationId, origin: "local" });
     },
     async getMemoryLinks(conversationId) {
-      const record2 = await child("memory_links", conversationId);
-      return record2 && !record2.isDeleted ? toLinks(record2) : [];
+      const record3 = await child("memory_links", conversationId);
+      return record3 && !record3.isDeleted ? toLinks(record3) : [];
     },
     async addMemoryLinks(conversationId, items) {
       if (!conversationId || items.length === 0) return;
@@ -14372,8 +14801,8 @@ function createVaultChatBackend(options) {
       emit({ type: "links", conversationId, origin: "local" });
     },
     async clearMemoryLinks(conversationId) {
-      const record2 = await child("memory_links", conversationId);
-      if (!record2 || record2.isDeleted) return;
+      const record3 = await child("memory_links", conversationId);
+      if (!record3 || record3.isDeleted) return;
       await enqueue({
         kind: "memory_links",
         id: conversationId,
@@ -14391,8 +14820,8 @@ function createVaultChatBackend(options) {
     async importChats(chats) {
       await ready();
       const seen = /* @__PURE__ */ new Set();
-      const unique = (items) => items.filter(({ record: record2 }) => {
-        const k = key2(record2.kind, record2.id);
+      const unique = (items) => items.filter(({ record: record3 }) => {
+        const k = key2(record3.kind, record3.id);
         if (seen.has(k)) return false;
         seen.add(k);
         return true;
@@ -14416,15 +14845,15 @@ function createVaultChatBackend(options) {
         for (const batch of batches(messages))
           messageCount += await connected.importRecords(batch);
       } finally {
-        for (const { record: record2 } of messages) checked.delete(key2("message", record2.id));
-        await refresh(conversations.map(({ record: record2 }) => key2("conversation", record2.id))).catch(
+        for (const { record: record3 } of messages) checked.delete(key2("message", record3.id));
+        await refresh(conversations.map(({ record: record3 }) => key2("conversation", record3.id))).catch(
           () => void 0
         );
-        for (const { record: record2 } of conversations) threads.delete(record2.id);
+        for (const { record: record3 } of conversations) threads.delete(record3.id);
         channel?.postMessage("changed");
         emit({ type: "conversations", origin: "local" });
-        for (const { record: record2 } of conversations)
-          emit({ type: "messages", conversationId: record2.id, origin: "local" });
+        for (const { record: record3 } of conversations)
+          emit({ type: "messages", conversationId: record3.id, origin: "local" });
       }
       return { conversations: conversationCount, messages: messageCount };
     },
@@ -14443,8 +14872,8 @@ function createVaultChatBackend(options) {
     }
   };
   const updateConversation = async (conversationId, set) => {
-    const record2 = await conversation(conversationId);
-    if (!record2 || record2.isDeleted) return false;
+    const record3 = await conversation(conversationId);
+    if (!record3 || record3.isDeleted) return false;
     await enqueue({ kind: "conversation", id: conversationId, conversationId: "", set });
     emit({ type: "conversations", origin: "local" });
     return true;
@@ -14620,10 +15049,10 @@ async function decryptConversationTitle(encryptedTitle, address) {
     );
   }
   const cacheKey = buildCacheKey(address, encryptedTitle);
-  const cached = titleCache.get(cacheKey);
-  if (cached !== void 0) {
-    touchEntry(cacheKey, cached);
-    return cached;
+  const cached2 = titleCache.get(cacheKey);
+  if (cached2 !== void 0) {
+    touchEntry(cacheKey, cached2);
+    return cached2;
   }
   const inFlight = pendingDecrypts.get(cacheKey);
   if (inFlight) return inFlight;
@@ -14882,25 +15311,25 @@ async function upsertEntitiesInWrite(ctx, entities) {
   const kindBackfills = existing.filter((e) => {
     const incoming = kindByName.get(e.canonicalName);
     return incoming !== void 0 && (e.kind === null || e.kind === void 0 || e.kind === "");
-  }).map((record2) => ({ record: record2, kind: kindByName.get(record2.canonicalName) }));
+  }).map((record3) => ({ record: record3, kind: kindByName.get(record3.canonicalName) }));
   const missing2 = unique.filter((n) => !existingNames.has(n));
   const created = missing2.map(
-    (name) => ctx.entityCollection.prepareCreate((record2) => {
-      record2._setRaw("canonical_name", name);
+    (name) => ctx.entityCollection.prepareCreate((record3) => {
+      record3._setRaw("canonical_name", name);
       const kind = kindByName.get(name);
-      if (kind !== void 0) record2._setRaw("kind", kind);
+      if (kind !== void 0) record3._setRaw("kind", kind);
     })
   );
   for (const e of existing) out.set(e.canonicalName, entityToStored(e));
-  for (const record2 of created) out.set(record2.canonicalName, entityToStored(record2));
-  for (const { record: record2, kind } of kindBackfills) {
-    out.set(record2.canonicalName, { ...entityToStored(record2), kind });
+  for (const record3 of created) out.set(record3.canonicalName, entityToStored(record3));
+  for (const { record: record3, kind } of kindBackfills) {
+    out.set(record3.canonicalName, { ...entityToStored(record3), kind });
   }
   return { entities: out, operations: created, kindBackfills };
 }
 function prepareKindBackfills(backfills) {
   return backfills.map(
-    ({ record: record2, kind }) => record2.prepareUpdate((r) => {
+    ({ record: record3, kind }) => record3.prepareUpdate((r) => {
       r._setRaw("kind", kind);
     })
   );
@@ -15028,10 +15457,10 @@ async function linkMemoryEntitiesOp(ctx, memoryId, entityInputs, options) {
       return;
     }
     const linkOps = toCreate.map(
-      (e) => ctx.memoryEntityCollection.prepareCreate((record2) => {
-        record2._setRaw("memory_id", memoryId);
-        record2._setRaw("entity_id", e.uniqueId);
-        if (userId !== void 0) record2._setRaw("user_id", userId);
+      (e) => ctx.memoryEntityCollection.prepareCreate((record3) => {
+        record3._setRaw("memory_id", memoryId);
+        record3._setRaw("entity_id", e.uniqueId);
+        if (userId !== void 0) record3._setRaw("user_id", userId);
       })
     );
     await ctx.database.batch(
@@ -15101,10 +15530,10 @@ async function replaceMemoryEntities(ctx, memoryId, entityInputs, options) {
       ...entityOps,
       ...prepareKindBackfills(kindBackfills),
       ...toCreate.map(
-        (e) => ctx.memoryEntityCollection.prepareCreate((record2) => {
-          record2._setRaw("memory_id", memoryId);
-          record2._setRaw("entity_id", e.uniqueId);
-          if (userId !== void 0) record2._setRaw("user_id", userId);
+        (e) => ctx.memoryEntityCollection.prepareCreate((record3) => {
+          record3._setRaw("memory_id", memoryId);
+          record3._setRaw("entity_id", e.uniqueId);
+          if (userId !== void 0) record3._setRaw("user_id", userId);
         })
       ),
       ...toDestroy.map((l) => l.prepareDestroyPermanently()),
@@ -16438,9 +16867,9 @@ var DatabaseManager = class {
    */
   getDatabase(walletAddress) {
     const dbName = this.getDbName(walletAddress);
-    const cached = this.databases.get(dbName);
-    if (cached) {
-      return cached;
+    const cached2 = this.databases.get(dbName);
+    if (cached2) {
+      return cached2;
     }
     const needsMigration = this.handleSchemaMigration(walletAddress);
     if (needsMigration) {
@@ -17575,8 +18004,8 @@ function visibilityConditions(requested) {
   if (excluded.length === 0) return [];
   return [Q9.or(Q9.where("visibility", null), Q9.where("visibility", Q9.notIn(excluded)))];
 }
-function isKinded(record2) {
-  return record2.kind !== null && record2.kind !== void 0;
+function isKinded(record3) {
+  return record3.kind !== null && record3.kind !== void 0;
 }
 async function assertCanWrite2(ctx) {
   if (ctx.canWrite && !await ctx.canWrite()) {
@@ -17630,8 +18059,8 @@ function levelConditions(requested) {
   }
   return [byLevel];
 }
-function isOwnedByCtxUser(ctx, record2) {
-  return ctx.userId === void 0 || record2.userId === ctx.userId;
+function isOwnedByCtxUser(ctx, record3) {
+  return ctx.userId === void 0 || record3.userId === ctx.userId;
 }
 function baseVaultConditions(ctx, options) {
   return [
@@ -17714,43 +18143,43 @@ async function vaultMemoryToStored(memory, walletAddress, signMessage, embeddedW
   }
   return raw;
 }
-function populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue) {
+function populateNewVaultMemory(record3, ctx, opts, encryptedContent, encryptedKindValue) {
   const { level, scope } = resolveCreateLevel(opts);
-  record2._setRaw("content", encryptedContent);
-  record2._setRaw("scope", scope);
-  record2._setRaw("level", level);
-  record2._setRaw("kind", opts.kind ?? null);
-  record2._setRaw("kind_value", encryptedKindValue ?? null);
-  record2._setRaw("folder_id", opts.folderId ?? null);
-  record2._setRaw("user_id", ctx.userId ?? null);
-  record2._setRaw("is_deleted", false);
+  record3._setRaw("content", encryptedContent);
+  record3._setRaw("scope", scope);
+  record3._setRaw("level", level);
+  record3._setRaw("kind", opts.kind ?? null);
+  record3._setRaw("kind_value", encryptedKindValue ?? null);
+  record3._setRaw("folder_id", opts.folderId ?? null);
+  record3._setRaw("user_id", ctx.userId ?? null);
+  record3._setRaw("is_deleted", false);
   if (opts.embedding !== void 0) {
-    record2._setRaw("embedding", opts.embedding);
-    record2._setRaw("embedding_model", opts.embeddingModel ?? null);
+    record3._setRaw("embedding", opts.embedding);
+    record3._setRaw("embedding_model", opts.embeddingModel ?? null);
   }
   if (opts.sourceChunkIds !== void 0) {
-    record2._setRaw("source_chunk_ids", serializeSourceChunkIds(opts.sourceChunkIds));
+    record3._setRaw("source_chunk_ids", serializeSourceChunkIds(opts.sourceChunkIds));
   }
-  record2._setRaw("proof_count", opts.proofCount ?? 1);
-  record2._setRaw("source", opts.source ?? "manual");
+  record3._setRaw("proof_count", opts.proofCount ?? 1);
+  record3._setRaw("source", opts.source ?? "manual");
   if (opts.eventTime) {
-    record2._setRaw("event_time_start", opts.eventTime.start ?? null);
-    record2._setRaw("event_time_end", opts.eventTime.end ?? null);
-    record2._setRaw("event_time_kind", opts.eventTime.kind ?? null);
+    record3._setRaw("event_time_start", opts.eventTime.start ?? null);
+    record3._setRaw("event_time_end", opts.eventTime.end ?? null);
+    record3._setRaw("event_time_kind", opts.eventTime.kind ?? null);
   }
   if (opts.factType !== void 0) {
-    record2._setRaw("fact_type", opts.factType);
+    record3._setRaw("fact_type", opts.factType);
   }
   if (opts.trustTier !== void 0) {
-    record2._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
+    record3._setRaw("trust_tier", normalizeTrustTier(opts.trustTier));
   }
-  record2._setRaw("visibility", opts.visibility ?? "private");
-  record2._setRaw(
+  record3._setRaw("visibility", opts.visibility ?? "private");
+  record3._setRaw(
     "published_at",
     opts.visibility && opts.visibility !== "private" ? opts.publishedAt ?? Date.now() : null
   );
   if (opts.geohash !== void 0) {
-    record2._setRaw("geohash", opts.geohash);
+    record3._setRaw("geohash", opts.geohash);
   }
 }
 async function createVaultMemoryOp(ctx, opts) {
@@ -17765,7 +18194,7 @@ async function createVaultMemoryOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
     return ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
+      (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContent, encryptedKindValue)
     );
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
@@ -17792,7 +18221,7 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
     if (target.isDeleted || target.supersededBy || isKinded(target) || !isOwnedByCtxUser(ctx, target))
       return;
     createdRecord = await ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
+      (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContent, encryptedKindValue)
     );
     await target.update((r) => {
       r._setRaw("superseded_by", createdRecord.id);
@@ -17877,7 +18306,7 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
     await assertCanWrite2(ctx);
     const prepared = optionsArray.map(
       (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
-        (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i], encryptedKindValues[i])
+        (record3) => populateNewVaultMemory(record3, ctx, opts, encryptedContents[i], encryptedKindValues[i])
       )
     );
     await ctx.database.batch(...prepared);
@@ -17885,16 +18314,16 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
   });
   return Promise.all(
     created.map(
-      (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+      (record3) => vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
     )
   );
 }
 async function getVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
     return vaultMemoryToStored(
-      record2,
+      record3,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -18233,29 +18662,29 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
       ctx.embeddedWalletSigner
     ) : opts.content;
     let stale = false;
-    const record2 = probe;
+    const record3 = probe;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2) || opts.expectedContent !== void 0 && record2._getRaw("content") !== readStoredContent) {
+      if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3) || opts.freeFormOnly && isKinded(record3) || opts.expectedContent !== void 0 && record3._getRaw("content") !== readStoredContent) {
         stale = true;
         return;
       }
-      const originalUpdatedAt = record2.updatedAt.getTime();
-      const nextKind = opts.kind !== void 0 ? opts.kind : record2.kind;
-      const nextLevel = levelAfter(record2);
+      const originalUpdatedAt = record3.updatedAt.getTime();
+      const nextKind = opts.kind !== void 0 ? opts.kind : record3.kind;
+      const nextLevel = levelAfter(record3);
       assertValidKindLevel(nextKind, nextLevel);
       let observedSources = [];
       let replayedObservation = false;
       if (opts.observationSourceIds?.length) {
         try {
-          const parsed = JSON.parse(record2.sourceChunkIds ?? "[]");
+          const parsed = JSON.parse(record3.sourceChunkIds ?? "[]");
           if (Array.isArray(parsed))
             observedSources = parsed.filter((id3) => typeof id3 === "string");
         } catch {
         }
         replayedObservation = opts.observationSourceIds.every((id3) => observedSources.includes(id3));
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         if (encryptedContent !== void 0) r._setRaw("content", encryptedContent);
         if (opts.level !== void 0) {
           r._setRaw("level", nextLevel);
@@ -18322,7 +18751,7 @@ async function updateVaultMemoryOp(ctx, id2, opts) {
     });
     if (stale) return null;
     return vaultMemoryToStored(
-      record2,
+      record3,
       ctx.walletAddress,
       ctx.signMessage,
       ctx.embeddedWalletSigner
@@ -18337,22 +18766,22 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
   if (!entityCtx) {
     throw new Error("setMemoryEntitiesOp requires ctx.entityCtx (entity collections)");
   }
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(memoryId);
+    record3 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return null;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
   let stale = false;
-  const originalUpdatedAt = record2.updatedAt.getTime();
+  const originalUpdatedAt = record3.updatedAt.getTime();
   await ctx.database.write(async (writer) => {
     await assertCanWrite2(ctx);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
       stale = true;
       return;
     }
-    await record2.update((r) => {
+    await record3.update((r) => {
       r._setRaw("topics_user_managed", true);
       r._setRaw("updated_at", originalUpdatedAt);
     });
@@ -18376,26 +18805,26 @@ async function setMemoryEntitiesOp(ctx, memoryId, entities) {
     );
   });
   if (stale) return null;
-  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(memoryId);
+    record3 = await ctx.vaultMemoryCollection.find(memoryId);
   } catch {
     return false;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
-  const originalUpdatedAt = record2.updatedAt.getTime();
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
+  const originalUpdatedAt = record3.updatedAt.getTime();
   let cleared = false;
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
-    if (options?.unlessTopicsRecorded && parseTopics(record2.topics) !== null) return;
+    if (options?.unlessTopicsRecorded && parseTopics(record3.topics) !== null) return;
     cleared = true;
-    await record2.update((r) => {
+    await record3.update((r) => {
       r._setRaw("topics_user_managed", false);
       r._setRaw("topics_extracted_version", null);
-      if (record2.topicsExtractedAt === null) {
+      if (record3.topicsExtractedAt === null) {
         r._setRaw("topics_extracted_at", originalUpdatedAt);
       }
       r._setRaw("updated_at", originalUpdatedAt);
@@ -18404,23 +18833,23 @@ async function clearMemoryTopicsOverrideOp(ctx, memoryId, options) {
   return cleared;
 }
 async function setMemoryVisibilityOp(ctx, id2, opts) {
-  let record2;
+  let record3;
   try {
-    record2 = await ctx.vaultMemoryCollection.find(id2);
+    record3 = await ctx.vaultMemoryCollection.find(id2);
   } catch {
     return null;
   }
-  if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return null;
+  if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return null;
   let stale = false;
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
       stale = true;
       return;
     }
-    const currentUpdatedAt = record2.updatedAt.getTime();
-    const currentPublishedAt = record2.publishedAt ?? null;
-    await record2.update((r) => {
+    const currentUpdatedAt = record3.updatedAt.getTime();
+    const currentPublishedAt = record3.publishedAt ?? null;
+    await record3.update((r) => {
       r._setRaw("visibility", opts.visibility);
       if (opts.visibility === "private") {
         r._setRaw("published_at", null);
@@ -18434,20 +18863,20 @@ async function setMemoryVisibilityOp(ctx, id2, opts) {
     });
   });
   if (stale) return null;
-  return vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
+  return vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function deleteVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -18466,9 +18895,9 @@ async function deleteVaultMemoryOp(ctx, id2) {
 async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
   if (id2 === supersededById) return false;
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) return false;
-    if (isKinded(record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3)) return false;
+    if (isKinded(record3)) return false;
     let successor;
     try {
       successor = await ctx.vaultMemoryCollection.find(supersededById);
@@ -18481,7 +18910,7 @@ async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || record3.supersededBy || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
@@ -18489,7 +18918,7 @@ async function supersedeVaultMemoryOp(ctx, id2, supersededById) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("superseded_by", supersededById);
         r._setRaw("superseded_at", Date.now());
       });
@@ -18508,7 +18937,7 @@ async function getUnfiledVaultMemoriesOp(ctx) {
   const results = await ctx.vaultMemoryCollection.query(...conditions).fetch();
   return mapInBatches(
     results,
-    (record2) => vaultMemoryToStored(record2, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
+    (record3) => vaultMemoryToStored(record3, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner)
   );
 }
 var TOPICS_EXTRACTION_VERSION = 3;
@@ -18669,17 +19098,17 @@ async function stampTopicsExtractedAtOp(ctx, memoryIds, extractedAt, version = T
         }
       }
       const eligible = records.filter(
-        (record2) => !record2.isDeleted && isOwnedByCtxUser(ctx, record2) && !record2.topicsUserManaged
+        (record3) => !record3.isDeleted && isOwnedByCtxUser(ctx, record3) && !record3.topicsUserManaged
       );
-      const prepared = eligible.map((record2) => {
-        const originalUpdatedAt = record2.updatedAt.getTime();
-        return record2.prepareUpdate((r) => {
+      const prepared = eligible.map((record3) => {
+        const originalUpdatedAt = record3.updatedAt.getTime();
+        return record3.prepareUpdate((r) => {
           r._setRaw("topics_extracted_at", extractedAt);
           r._setRaw("topics_extracted_version", version);
           r._setRaw("updated_at", originalUpdatedAt);
         });
       });
-      for (const record2 of eligible) stamped.push(record2.id);
+      for (const record3 of eligible) stamped.push(record3.id);
       if (prepared.length > 0) await ctx.database.batch(...prepared);
     });
   }
@@ -18695,14 +19124,14 @@ async function relinkMemoryTopicsOp(ctx, memoryIds) {
     try {
       await ctx.database.write(async (writer) => {
         await assertCanWrite2(ctx);
-        let record2;
+        let record3;
         try {
-          record2 = await ctx.vaultMemoryCollection.find(id2);
+          record3 = await ctx.vaultMemoryCollection.find(id2);
         } catch {
           return;
         }
-        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
-        const topics = parseTopics(record2.topics);
+        if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return;
+        const topics = parseTopics(record3.topics);
         if (topics === null) return;
         await writer.callWriter(() => relinkMemoryEntitiesFromTopicsOp(entityCtx, id2, topics));
         relinked.push(id2);
@@ -18728,18 +19157,18 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
       await assertCanWrite2(ctx);
       const records = [];
       for (const id2 of chunkIds) {
-        let record2;
+        let record3;
         try {
-          record2 = await ctx.vaultMemoryCollection.find(id2);
+          record3 = await ctx.vaultMemoryCollection.find(id2);
         } catch {
           continue;
         }
-        if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) continue;
-        if (parseTopics(record2.topics) !== null) continue;
-        records.push(record2);
+        if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) continue;
+        if (parseTopics(record3.topics) !== null) continue;
+        records.push(record3);
       }
       if (records.length === 0) return;
-      const links2 = await entityCtx.memoryEntityCollection.query(Q9.where("memory_id", Q9.oneOf(records.map((record2) => record2.id)))).unsafeFetchRaw();
+      const links2 = await entityCtx.memoryEntityCollection.query(Q9.where("memory_id", Q9.oneOf(records.map((record3) => record3.id)))).unsafeFetchRaw();
       const entityIds = Array.from(new Set(links2.map((link) => String(link.entity_id))));
       const entitiesById = /* @__PURE__ */ new Map();
       for (let j = 0; j < entityIds.length; j += CHUNK) {
@@ -18759,13 +19188,13 @@ async function backfillMemoryTopicsOp(ctx, memoryIds) {
         entities.add(entity);
       }
       const writes = [];
-      for (const record2 of records) {
-        const entities = entitiesByMemory.get(record2.id);
+      for (const record3 of records) {
+        const entities = entitiesByMemory.get(record3.id);
         if (!entities?.size) continue;
-        const source = record2.topicsUserManaged ? "user" : "auto";
+        const source = record3.topicsUserManaged ? "user" : "auto";
         const write = await resolveMemoryTopicsWrite(
           entityCtx,
-          record2.id,
+          record3.id,
           Array.from(entities),
           [],
           source
@@ -18787,7 +19216,7 @@ async function deleteAllVaultMemoriesForUserOp(ctx, userId) {
   await ctx.database.write(async () => {
     await assertCanWrite2(ctx);
     const prepared = records.map(
-      (record2) => record2.prepareUpdate((r) => {
+      (record3) => record3.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       })
     );
@@ -18858,22 +19287,22 @@ async function applyDecayTransitionsOp(ctx, candidates, opts) {
           Q9.where("id", Q9.oneOf(ids.slice(i, i + CHUNK))),
           ...ctx.userId !== void 0 ? [Q9.where("user_id", ctx.userId)] : []
         ).fetch();
-        const eligible = records.filter((record2) => {
-          if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+        const eligible = records.filter((record3) => {
+          if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
           if (opts.transition === "delete") {
-            return record2.archivedAt !== null && opts.now - record2.archivedAt > opts.hardDeleteWindowMs;
+            return record3.archivedAt !== null && opts.now - record3.archivedAt > opts.hardDeleteWindowMs;
           }
-          const candidate = byId.get(record2.id);
-          return record2.archivedAt === null && record2.updatedAt.getTime() === candidate.updatedAt && (record2.lastObservedAt ?? null) === (candidate.lastObservedAt ?? null);
+          const candidate = byId.get(record3.id);
+          return record3.archivedAt === null && record3.updatedAt.getTime() === candidate.updatedAt && (record3.lastObservedAt ?? null) === (candidate.lastObservedAt ?? null);
         });
         const prepared = eligible.map(
-          (record2) => record2.prepareUpdate((row) => {
+          (record3) => record3.prepareUpdate((row) => {
             if (opts.transition === "archive") row._setRaw("archived_at", opts.now);
             else row._setRaw("is_deleted", true);
           })
         );
         if (prepared.length > 0) await ctx.database.batch(prepared);
-        applied = eligible.map((record2) => record2.id);
+        applied = eligible.map((record3) => record3.id);
       });
     } catch {
       continue;
@@ -18891,21 +19320,21 @@ async function applyDecayTransitionsOp(ctx, candidates, opts) {
 }
 async function archiveVaultMemoryOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     const archivedAtValue = opts?.now ?? Date.now();
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || record2.archivedAt !== null) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3) || record3.archivedAt !== null) {
         stale = true;
         return;
       }
-      if (opts?.expectedUpdatedAt !== void 0 && record2.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record2.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
+      if (opts?.expectedUpdatedAt !== void 0 && record3.updatedAt.getTime() !== opts.expectedUpdatedAt || opts?.expectedLastObservedAt !== void 0 && (record3.lastObservedAt ?? null) !== opts.expectedLastObservedAt) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("archived_at", archivedAtValue);
       });
     });
@@ -18916,16 +19345,16 @@ async function archiveVaultMemoryOp(ctx, id2, opts) {
 }
 async function restoreVaultMemoryOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) {
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("archived_at", null);
       });
     });
@@ -18936,18 +19365,18 @@ async function restoreVaultMemoryOp(ctx, id2) {
 }
 async function hardDeleteDecayedOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
     const now = opts.now ?? Date.now();
     let stale = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      const archivedAt = record2.archivedAt;
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
+      const archivedAt = record3.archivedAt;
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3) || archivedAt === null || now - archivedAt <= opts.hardDeleteWindowMs) {
         stale = true;
         return;
       }
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("is_deleted", true);
       });
     });
@@ -18965,14 +19394,14 @@ async function hardDeleteDecayedOp(ctx, id2, opts) {
 }
 async function updateVaultMemoryEmbeddingOp(ctx, id2, embedding2, embeddingModel, expected) {
   try {
-    const record2 = await ctx.vaultMemoryCollection.find(id2);
-    if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return false;
-    const readUpdatedAt = record2.updatedAt.getTime();
-    const readStoredContent = record2._getRaw("content");
+    const record3 = await ctx.vaultMemoryCollection.find(id2);
+    if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return false;
+    const readUpdatedAt = record3.updatedAt.getTime();
+    const readStoredContent = record3._getRaw("content");
     if (expected?.updatedAt !== void 0 && expected.updatedAt !== readUpdatedAt) return false;
     if (expected?.content !== void 0) {
       const current = await vaultMemoryToStored(
-        record2,
+        record3,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
@@ -18982,11 +19411,11 @@ async function updateVaultMemoryEmbeddingOp(ctx, id2, embedding2, embeddingModel
     let written = false;
     await ctx.database.write(async () => {
       await assertCanWrite2(ctx);
-      if (record2.isDeleted || !isOwnedByCtxUser(ctx, record2)) return;
-      const originalUpdatedAt = record2.updatedAt.getTime();
-      if (originalUpdatedAt !== readUpdatedAt || record2._getRaw("content") !== readStoredContent)
+      if (record3.isDeleted || !isOwnedByCtxUser(ctx, record3)) return;
+      const originalUpdatedAt = record3.updatedAt.getTime();
+      if (originalUpdatedAt !== readUpdatedAt || record3._getRaw("content") !== readStoredContent)
         return;
-      await record2.update((r) => {
+      await record3.update((r) => {
         r._setRaw("embedding", embedding2);
         r._setRaw("embedding_model", embeddingModel);
         r._setRaw("updated_at", originalUpdatedAt);
@@ -19150,26 +19579,26 @@ async function ingestPublishedPhotoMemoriesOp(ctx, rows) {
     inserted = writable.length;
     if (writable.length === 0) return;
     const prepared = writable.map(
-      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record2) => {
-        record2._raw.id = row.memoryId;
-        record2._setRaw("content", content);
-        record2._setRaw("scope", "shared");
-        record2._setRaw("level", "matching");
-        record2._setRaw("folder_id", null);
-        record2._setRaw("user_id", ctx.userId ?? null);
-        record2._setRaw("is_deleted", false);
-        record2._setRaw("proof_count", 1);
-        record2._setRaw("source", SOURCE_PHOTO);
-        record2._setRaw(
+      ({ row, content }) => ctx.vaultMemoryCollection.prepareCreate((record3) => {
+        record3._raw.id = row.memoryId;
+        record3._setRaw("content", content);
+        record3._setRaw("scope", "shared");
+        record3._setRaw("level", "matching");
+        record3._setRaw("folder_id", null);
+        record3._setRaw("user_id", ctx.userId ?? null);
+        record3._setRaw("is_deleted", false);
+        record3._setRaw("proof_count", 1);
+        record3._setRaw("source", SOURCE_PHOTO);
+        record3._setRaw(
           "media",
           row.media && row.media.length > 0 ? JSON.stringify(row.media) : null
         );
-        record2._setRaw("visibility", "public");
-        record2._setRaw("published_at", now);
+        record3._setRaw("visibility", "public");
+        record3._setRaw("published_at", now);
         if (row.eventTime) {
-          record2._setRaw("event_time_start", row.eventTime.start ?? null);
-          record2._setRaw("event_time_end", row.eventTime.end ?? null);
-          record2._setRaw("event_time_kind", row.eventTime.kind ?? null);
+          record3._setRaw("event_time_start", row.eventTime.start ?? null);
+          record3._setRaw("event_time_end", row.eventTime.end ?? null);
+          record3._setRaw("event_time_kind", row.eventTime.kind ?? null);
         }
       })
     );
@@ -20000,11 +20429,11 @@ function folderToStored(folder) {
 }
 async function createVaultFolderOp(ctx, opts) {
   const created = await ctx.database.write(async () => {
-    return ctx.vaultFolderCollection.create((record2) => {
-      record2._setRaw("name", opts.name);
-      record2._setRaw("scope", opts.scope ?? "private");
-      record2._setRaw("is_system", opts.isSystem ?? false);
-      record2._setRaw("is_deleted", false);
+    return ctx.vaultFolderCollection.create((record3) => {
+      record3._setRaw("name", opts.name);
+      record3._setRaw("scope", opts.scope ?? "private");
+      record3._setRaw("is_system", opts.isSystem ?? false);
+      record3._setRaw("is_deleted", false);
     });
   });
   return folderToStored(created);
@@ -20015,14 +20444,14 @@ async function getAllVaultFoldersOp(ctx) {
 }
 async function updateVaultFolderOp(ctx, id2, opts) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return null;
-    const scopeChanged = opts.scope !== void 0 && opts.scope !== record2.scope;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return null;
+    const scopeChanged = opts.scope !== void 0 && opts.scope !== record3.scope;
     const updated = await ctx.database.write(async () => {
       const memories = scopeChanged ? await ctx.vaultMemoryCollection.query(Q15.where("folder_id", id2), Q15.where("is_deleted", false)).fetch() : [];
       const updates = [];
       updates.push(
-        record2.prepareUpdate((r) => {
+        record3.prepareUpdate((r) => {
           if (opts.name !== void 0) r._setRaw("name", opts.name);
           if (opts.scope !== void 0) r._setRaw("scope", opts.scope);
         })
@@ -20045,8 +20474,8 @@ async function updateVaultFolderOp(ctx, id2, opts) {
 }
 async function deleteVaultFolderOp(ctx, id2) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return false;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return false;
     await ctx.database.write(async () => {
       const memories = await ctx.vaultMemoryCollection.query(Q15.where("folder_id", id2), Q15.where("is_deleted", false)).fetch();
       const preparedMemories = memories.map(
@@ -20056,7 +20485,7 @@ async function deleteVaultFolderOp(ctx, id2) {
           r._setRaw("scope", "private");
         })
       );
-      const preparedFolder = record2.prepareUpdate((r) => {
+      const preparedFolder = record3.prepareUpdate((r) => {
         r._setRaw("is_deleted", true);
       });
       await ctx.database.batch(...preparedMemories, preparedFolder);
@@ -20103,11 +20532,11 @@ async function moveMemoriesToFolderOp(ctx, memoryIds, folderId) {
 }
 async function updateVaultFolderContextOp(ctx, id2, context) {
   try {
-    const record2 = await ctx.vaultFolderCollection.find(id2);
-    if (record2.isDeleted) return null;
+    const record3 = await ctx.vaultFolderCollection.find(id2);
+    if (record3.isDeleted) return null;
     const updated = await ctx.database.write(async () => {
       await ctx.database.batch(
-        record2.prepareUpdate((r) => {
+        record3.prepareUpdate((r) => {
           r._setRaw("context", context);
         })
       );
@@ -21201,9 +21630,9 @@ function loadVaultCorpus(ctx, options, preparation) {
   const key3 = JSON.stringify(options ?? {});
   let request = pending.get(key3);
   if (!request) {
-    const entries = pending;
+    const entries2 = pending;
     request = getAllVaultMemoriesOp(ctx, options).catch((error) => {
-      entries.delete(key3);
+      entries2.delete(key3);
       throw error;
     });
     pending.set(key3, request);
@@ -21244,7 +21673,7 @@ function embedVaultRows(ctx, options, rows, preparation) {
     if (!pending.has(keys[index]) && !prepared?.has(keys[index])) missing2.set(keys[index], row);
   });
   if (missing2.size > 0) {
-    const entries = pending;
+    const entries2 = pending;
     const batch = Promise.resolve().then(
       () => generateEmbeddings(
         [...missing2.values()].map((row) => row.content),
@@ -21261,16 +21690,16 @@ function embedVaultRows(ctx, options, rows, preparation) {
         });
         return vector2;
       }).finally(() => {
-        entries.delete(key3);
-        if (entries.size === 0) pendingRows.get(ctx)?.delete(options.maskInput);
+        entries2.delete(key3);
+        if (entries2.size === 0) pendingRows.get(ctx)?.delete(options.maskInput);
       });
       pending.set(key3, request);
     });
   }
   return Promise.all(
     keys.map((key3) => {
-      const cached = prepared?.get(key3);
-      if (cached) return cached;
+      const cached2 = prepared?.get(key3);
+      if (cached2) return cached2;
       const request = pending.get(key3);
       if (!prepared) return request;
       const retained = request.catch((error) => {
@@ -21970,10 +22399,10 @@ async function buildProjectedCorpus(query, vaultCtx, embeddingOptions, cache, qu
   const resolvedThisCall = /* @__PURE__ */ new Set();
   if (!embeddingsDegraded) {
     for (const k2 of keys) {
-      const cached = cachedRowVector(cache, k2.uniqueId, k2.updatedAt);
-      if (cached && cached.length === queryEmbedding.length) {
+      const cached2 = cachedRowVector(cache, k2.uniqueId, k2.updatedAt);
+      if (cached2 && cached2.length === queryEmbedding.length) {
         corpusStats.cacheHits++;
-        vectored.push({ uniqueId: k2.uniqueId, embedding: cached, updatedAt: k2.updatedAt });
+        vectored.push({ uniqueId: k2.uniqueId, embedding: cached2, updatedAt: k2.updatedAt });
         continue;
       }
       corpusStats.cacheMisses++;
@@ -22271,12 +22700,12 @@ async function prepareVaultCandidates(query, vaultCtx, embeddingOptions, cache,
     for (let i = 0; queryEmbedding.length > 0 && i < memories.length; i++) {
       const content = memories[i].content;
       const memoryId = memories[i].uniqueId;
-      const cached = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
-      if (cached && cached.length === queryEmbedding.length) {
-        resolvedVectors.set(memoryId, cached);
+      const cached2 = cachedRowVector(cache, memoryId, memories[i].updatedAt, content);
+      if (cached2 && cached2.length === queryEmbedding.length) {
+        resolvedVectors.set(memoryId, cached2);
         continue;
       }
-      if (cached) cache.delete(memoryId);
+      if (cached2) cache.delete(memoryId);
       const storedModel = memories[i].embeddingModel;
       const modelCompatible = (storedModel ?? currentModel) === currentModel;
       if (memories[i].embedding && modelCompatible) {
@@ -23960,9 +24389,9 @@ function createDecaySweeperOver(backend, options) {
     if (ruleVerdict !== "keep") return rule;
     if (!classifier || !isBorderline(input)) return rule;
     if (input.id) {
-      const cached = classifierCache.get(input.id);
-      if (cached && cached.activityAt === lastActivityAt(input))
-        return { verdict: cached.verdict, source: "classifierDriven" };
+      const cached2 = classifierCache.get(input.id);
+      if (cached2 && cached2.activityAt === lastActivityAt(input))
+        return { verdict: cached2.verdict, source: "classifierDriven" };
     }
     if (sweep.classifierCalls >= maxClassifierCalls) {
       sweep.classifierCapHits++;
@@ -25811,21 +26240,21 @@ async function extractAndLinkEntitiesForMemoriesOp(ctx, memoryIds, options) {
   };
   const inputs = [];
   for (const id2 of new Set(memoryIds)) {
-    let record2;
+    let record3;
     try {
-      record2 = await ctx.vaultMemoryCollection.find(id2);
+      record3 = await ctx.vaultMemoryCollection.find(id2);
     } catch (err) {
       log.warn("[memory/topics] vault lookup failed for extraction", err);
       skip(id2, "not-found");
       continue;
     }
-    if (record2.isDeleted || ctx.userId !== void 0 && record2.userId !== ctx.userId || record2.topicsUserManaged) {
+    if (record3.isDeleted || ctx.userId !== void 0 && record3.userId !== ctx.userId || record3.topicsUserManaged) {
       skip(id2, "excluded");
       continue;
     }
     try {
       const stored2 = await vaultMemoryToStored(
-        record2,
+        record3,
         ctx.walletAddress,
         ctx.signMessage,
         ctx.embeddedWalletSigner
@@ -26132,6 +26561,7 @@ function createLocalMemoryStore(options) {
 
 // src/lib/memory/store/memoryKeys.ts
 var KEY_ID_DOMAIN = "anuma-private-memory-key-id-v1";
+var TOPIC_HASH_INFO = "anuma-private-memory-topic-hash-v1";
 var MemoryKeyError = class extends Error {
   constructor(message) {
     super(message);
@@ -26147,17 +26577,40 @@ async function importAesKey(hex) {
     ["encrypt", "decrypt"]
   );
 }
+async function deriveTopicHashKey(hex) {
+  const material = await crypto.subtle.importKey(
+    "raw",
+    hexToBytes(hex).buffer,
+    { name: "HKDF" },
+    false,
+    ["deriveBits"]
+  );
+  const bits = await crypto.subtle.deriveBits(
+    {
+      name: "HKDF",
+      hash: "SHA-256",
+      salt: new Uint8Array(32),
+      info: new TextEncoder().encode(TOPIC_HASH_INFO)
+    },
+    material,
+    256
+  );
+  return crypto.subtle.importKey("raw", bits, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+}
+function toHex(bytes4) {
+  return Array.from(new Uint8Array(bytes4), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
 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,
+    keyId: "v3:" + toHex(digest),
     v3: await importAesKey(v3Hex),
-    v2: await importAesKey(await deriveKeyFromSignature(signatureHex))
+    v2: await importAesKey(await deriveKeyFromSignature(signatureHex)),
+    topicHash: await deriveTopicHashKey(v3Hex)
   };
 }
 async function decryptWith(value, rings) {
@@ -26178,7 +26631,10 @@ function memoryCipher(canonical) {
       if (!ciphertext.startsWith("enc:v3:") || !isEncrypted(ciphertext))
         throw new MemoryKeyError("Remote memory content must be enc:v3 ciphertext");
       return decryptWith(ciphertext, [canonical]);
-    }
+    },
+    hashTopic: async (normalized2) => toHex(
+      await crypto.subtle.sign("HMAC", canonical.topicHash, new TextEncoder().encode(normalized2))
+    )
   };
 }
 async function reencryptMemoryField(value, canonical, fallbacks = []) {
@@ -26610,8 +27066,9 @@ var DEFAULT_RATE_LIMIT_WAIT_MS = 1e4;
 var MAX_ID_BYTES = 128;
 var MAX_CONTENT_BYTES = 32 << 10;
 var MAX_TEXT_BYTES = 16 << 10;
+var MAX_TOPICS_BYTES = 32 << 10;
 var MAX_SHORT_BYTES = 256;
-var TEXT_FIELDS = ["topics", "media", "source_chunk_ids"];
+var TEXT_FIELDS = ["media", "source_chunk_ids"];
 var SHORT_FIELDS = [
   "scope",
   "kind",
@@ -26714,7 +27171,7 @@ function bytes3(value) {
   return value === void 0 ? 0 : utf82.encode(value).length;
 }
 function fitsNearby(row) {
-  return bytes3(row.memory_id) <= MAX_ID_BYTES && bytes3(row.content) <= MAX_CONTENT_BYTES && bytes3(row.kind_value) <= MAX_CONTENT_BYTES && TEXT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_TEXT_BYTES) && SHORT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_SHORT_BYTES);
+  return bytes3(row.memory_id) <= MAX_ID_BYTES && bytes3(row.content) <= MAX_CONTENT_BYTES && bytes3(row.kind_value) <= MAX_CONTENT_BYTES && bytes3(row.topics) <= MAX_TOPICS_BYTES && sealedTopicNamesFit(row.topics) && TEXT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_TEXT_BYTES) && SHORT_FIELDS.every((field10) => bytes3(row[field10]) <= MAX_SHORT_BYTES);
 }
 function invalid2(raw) {
   const id2 = raw.id;
@@ -26758,7 +27215,7 @@ function defined(value) {
     Object.entries(value).filter(([, field10]) => field10 !== void 0)
   );
 }
-async function prepareRow(raw, canonical, rings, model, updatedAt) {
+async function prepareRow(raw, canonical, codec, rings, model, updatedAt) {
   const deleted = bool(raw.is_deleted) ?? false;
   const { encrypt } = memoryCipher(canonical);
   const localKindValue = text15(raw.kind_value);
@@ -26772,10 +27229,12 @@ async function prepareRow(raw, canonical, rings, model, updatedAt) {
     plaintext = void 0;
     kindValue = void 0;
   }
+  const fields = metadata2(raw, model);
   const row = {
     ...defined({
-      ...metadata2(raw, model),
-      kind_value: kindValue === void 0 ? void 0 : await encrypt(kindValue)
+      ...fields,
+      kind_value: kindValue === void 0 ? void 0 : await encrypt(kindValue),
+      topics: fields.topics === void 0 ? void 0 : await codec.encodeTopics(fields.topics)
     }),
     memory_id: raw.id,
     content: await encrypt(plaintext ?? ""),
@@ -26819,6 +27278,8 @@ function sameMetadata2(local, remote, model) {
     if (field10 === "visibility") return (a ?? "private") === (b ?? "private");
     if (field10 === "is_deleted" || field10 === "topics_user_managed" || field10 === "twin_opt_in")
       return (a ?? false) === (b ?? false);
+    if (field10 === "topics")
+      return JSON.stringify(parseTopics(a)) === JSON.stringify(parseTopics(b));
     return a === b;
   });
 }
@@ -26874,7 +27335,7 @@ async function missingIds(request, revisions, signal) {
   }
   return missing2;
 }
-async function remoteMetadata(request, ids, signal) {
+async function remoteMetadata(request, codec, ids, signal) {
   const rows = /* @__PURE__ */ new Map();
   for (const batch of chunks(ids, QUERY_IDS)) {
     let cursor;
@@ -26898,7 +27359,12 @@ async function remoteMetadata(request, ids, signal) {
       if (!Array.isArray(page.items)) throw new Error("Invalid nearby private-memory page");
       for (const item of page.items)
         if (item.memory && typeof item.memory.memory_id === "string")
-          rows.set(item.memory.memory_id, item.memory);
+          rows.set(item.memory.memory_id, {
+            ...item.memory,
+            ...typeof item.memory.topics === "string" && {
+              topics: await codec.decodeTopics(item.memory.topics).catch(() => null)
+            }
+          });
       cursor = typeof page.next_cursor === "string" ? page.next_cursor : void 0;
     } while (cursor);
   }
@@ -26916,6 +27382,7 @@ async function migrateMemoriesToRemote(options) {
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
   const request = createNearbyRequest(options);
+  const codec = createTopicCodec(memoryCipher(canonical));
   const account = await request("/account", {}, signal);
   if (typeof account.key_id === "string" && account.key_id !== canonical.keyId)
     throw new RemoteMemoryError(
@@ -26932,7 +27399,7 @@ async function migrateMemoriesToRemote(options) {
     ...typeof t.kind === "string" && { kind: t.kind }
   })).filter((t) => t.name.length > 0) : []);
   if (localTopics.length)
-    await createRemoteTopicPersistence(request).importTopics(localTopics, signal);
+    await createRemoteTopicPersistence(request, codec).importTopics(localTopics, signal);
   const skipped = /* @__PURE__ */ new Map();
   const reembedded = /* @__PURE__ */ new Set();
   const unembedded = /* @__PURE__ */ new Set();
@@ -26951,6 +27418,7 @@ async function migrateMemoriesToRemote(options) {
       if (pending.size === 0 && !active) {
         const remote = await remoteMetadata(
           request,
+          codec,
           candidates.map((raw) => raw.id),
           signal
         );
@@ -26995,7 +27463,7 @@ async function migrateMemoriesToRemote(options) {
         const updatedAt = pending.get(raw.id);
         if (updatedAt === void 0) continue;
         try {
-          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+          prepared.push(await prepareRow(raw, canonical, codec, rings, model, updatedAt));
         } catch (error) {
           if (!(error instanceof MemoryKeyError)) throw error;
           skipped.set(raw.id, "unreadable");
@@ -27154,7 +27622,7 @@ function topicInputs(topics, source) {
 function mergeTopics(existing, added) {
   const byName = /* @__PURE__ */ new Map();
   for (const topic2 of [...existing, ...added]) {
-    const key3 = normalizeEntityName(topic2.name);
+    const key3 = normalizeTopicName(topic2.name);
     const kept = byName.get(key3);
     if (!kept) byName.set(key3, topic2);
     else if (kept.weight !== void 0 && topic2.weight !== void 0 && topic2.weight > kept.weight)
@@ -27169,7 +27637,7 @@ function sameTopics(stored2, next) {
   return next.every((t) => keys.has(key3(t)));
 }
 function canonicalTopics(row) {
-  return new Set((parseTopics(row.topics) ?? []).map((topic2) => normalizeEntityName(topic2.name)));
+  return new Set((parseTopics(row.topics) ?? []).map((topic2) => normalizeTopicName(topic2.name)));
 }
 function createRemoteMemoryStore(options) {
   const { persistence, embeddingOptions } = options;
@@ -27216,10 +27684,10 @@ function createRemoteMemoryStore(options) {
   const notify = (change, records = []) => {
     invalidateReads();
     if (subscribers.size)
-      for (const record2 of records) {
-        const previous = seen.get(record2.memory.memory_id);
-        if ((previous?.version ?? 0) + 1 === record2.version)
-          seen.set(record2.memory.memory_id, subscriptionState(record2));
+      for (const record3 of records) {
+        const previous = seen.get(record3.memory.memory_id);
+        if ((previous?.version ?? 0) + 1 === record3.version)
+          seen.set(record3.memory.memory_id, subscriptionState(record3));
       }
     for (const subscriber of [...subscribers])
       if (relevant(change, subscriber.options)) safely(subscriber.onChange);
@@ -27272,7 +27740,7 @@ function createRemoteMemoryStore(options) {
   };
   const enumerate = (filters, max = Infinity) => pages(decrypted, filters, max);
   const memoriesByTopics = async (names) => {
-    const wanted = new Set(names.map(normalizeEntityName).filter(Boolean));
+    const wanted = new Set(names.map(normalizeTopicName).filter(Boolean));
     const out = /* @__PURE__ */ new Map();
     const pages2 = await Promise.all(
       chunks2([...wanted], MAX_QUERY_TOPICS).map((topics) => enumerate({ topics }))
@@ -27284,7 +27752,7 @@ function createRemoteMemoryStore(options) {
     return out;
   };
   const topicGraphRanking = async (query, recallOptions = {}) => {
-    const wanted = new Set(extractQueryEntities(query).map(normalizeEntityName).filter(Boolean));
+    const wanted = new Set(extractQueryEntities(query).map(normalizeTopicName).filter(Boolean));
     if (wanted.size === 0 || recallOptions.memoryIds?.length === 0) return [];
     const rows = await pages(
       metadata3,
@@ -27342,25 +27810,25 @@ function createRemoteMemoryStore(options) {
     return run;
   };
   const live2 = async (id2) => {
-    const record2 = await persistence.get(id2);
-    return record2 && !record2.memory.is_deleted ? record2 : null;
+    const record3 = await persistence.get(id2);
+    return record3 && !record3.memory.is_deleted ? record3 : null;
   };
   const mutateLocked = async (id2, change, edit, writeOptions) => {
     writeOptions?.signal?.throwIfAborted();
-    const record2 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live2(id2);
-    if (!record2) return null;
-    if (record2.memory.is_deleted) return null;
+    const record3 = writeOptions?.signal ? await persistence.get(id2, writeOptions.signal) : await live2(id2);
+    if (!record3) return null;
+    if (record3.memory.is_deleted) return null;
     if (writeOptions?.canWrite && !await writeOptions.canWrite())
       throw new MemorySourceIneligibleError();
     writeOptions?.signal?.throwIfAborted();
-    const next = edit(structuredClone(record2.memory));
+    const next = edit(structuredClone(record3.memory));
     if (!next) return null;
     const saved = writeOptions?.leaseToken ? (await persistence.putMany(
-      [{ memory: next, expectedVersion: record2 }],
+      [{ memory: next, expectedVersion: record3 }],
       writeOptions.signal,
       writeOptions.leaseToken
-    ))[0] : writeOptions?.signal ? await persistence.put(next, record2, writeOptions.signal) : await persistence.put(next, record2);
-    notify(typeof change === "function" ? change(record2.memory) : change, [saved]);
+    ))[0] : writeOptions?.signal ? await persistence.put(next, record3, writeOptions.signal) : await persistence.put(next, record3);
+    notify(typeof change === "function" ? change(record3.memory) : change, [saved]);
     return saved;
   };
   const mutate = (id2, change, edit, writeOptions) => serialized(id2, () => mutateLocked(id2, change, edit, writeOptions));
@@ -27382,12 +27850,12 @@ function createRemoteMemoryStore(options) {
         }
         const { records, unreadable } = read;
         for (const id2 of slice) {
-          const record2 = records.get(id2);
+          const record3 = records.get(id2);
           if (unreadable.has(id2)) failed.set(id2, new Error(`Memory ${id2} could not be decrypted`));
-          else if (!record2) failed.set(id2, new Error(`Memory ${id2} was not found`));
-          else if (!record2.memory.is_deleted) {
-            const memory = edit(structuredClone(record2.memory));
-            if (memory) writes.push({ before: record2, memory });
+          else if (!record3) failed.set(id2, new Error(`Memory ${id2} was not found`));
+          else if (!record3.memory.is_deleted) {
+            const memory = edit(structuredClone(record3.memory));
+            if (memory) writes.push({ before: record3, memory });
           }
         }
         if (writes.length === 0) return;
@@ -27398,10 +27866,10 @@ function createRemoteMemoryStore(options) {
             leaseToken
           );
           const byChange = /* @__PURE__ */ new Map();
-          written.forEach((record2, i) => {
-            saved.set(record2.memory.memory_id, record2);
+          written.forEach((record3, i) => {
+            saved.set(record3.memory.memory_id, record3);
             const kind = change(writes[i].before.memory);
-            byChange.set(kind, [...byChange.get(kind) ?? [], record2]);
+            byChange.set(kind, [...byChange.get(kind) ?? [], record3]);
           });
           for (const [kind, changed] of byChange) notify(kind, changed);
         } catch (error) {
@@ -27415,13 +27883,13 @@ function createRemoteMemoryStore(options) {
               continue;
             }
             try {
-              const record2 = await mutateLocked(
+              const record3 = await mutateLocked(
                 id2,
                 change,
                 edit,
                 leaseToken || signal ? { leaseToken, signal } : void 0
               );
-              if (record2) saved.set(id2, record2);
+              if (record3) saved.set(id2, record3);
             } catch (rowError) {
               signal?.throwIfAborted();
               if (isRemoteWorkLeaseExpired(rowError)) throw rowError;
@@ -27517,12 +27985,12 @@ function createRemoteMemoryStore(options) {
   const created = (records, inputs) => {
     embedInBackground(records.filter((_, i) => inputs[i].embedding === void 0));
     notify("membership", records);
-    return records.map((record2) => stored(record2.memory));
+    return records.map((record3) => stored(record3.memory));
   };
-  const asStored = (record2) => record2 ? stored(record2.memory) : null;
+  const asStored = (record3) => record3 ? stored(record3.memory) : null;
   const knownKinds = async (topics, signal) => {
     const unkinded = [
-      ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeEntityName(t.name)))
+      ...new Set(topics.filter((t) => !t.kind).map((t) => normalizeTopicName(t.name)))
     ];
     const kinds2 = /* @__PURE__ */ new Map();
     for (const names of chunks2(unkinded, MAX_QUERY_TOPICS)) {
@@ -27534,13 +28002,13 @@ function createRemoteMemoryStore(options) {
         ...signal && { signal }
       })) {
         for (const topic2 of parseTopics(memory.topics) ?? []) {
-          const name = normalizeEntityName(topic2.name);
+          const name = normalizeTopicName(topic2.name);
           if (topic2.kind && !kinds2.has(name)) kinds2.set(name, topic2.kind);
         }
       }
     }
     return (topic2) => {
-      const kind = topic2.kind ?? kinds2.get(normalizeEntityName(topic2.name));
+      const kind = topic2.kind ?? kinds2.get(normalizeTopicName(topic2.name));
       return kind ? { ...topic2, kind } : topic2;
     };
   };
@@ -27563,7 +28031,7 @@ function createRemoteMemoryStore(options) {
           ...cursor2 && { cursor: cursor2 }
         });
         warnFailed(page.failed);
-        for (const record2 of page.items) records.set(record2.memory.memory_id, record2);
+        for (const record3 of page.items) records.set(record3.memory.memory_id, record3);
         for (const failure of page.failed) unreadable.add(failure.memory_id);
         cursor2 = page.next_cursor;
       } while (cursor2);
@@ -27759,8 +28227,8 @@ function createRemoteMemoryStore(options) {
     const failed = /* @__PURE__ */ new Map();
     const collect = (page) => {
       warnFailed(page.failed);
-      for (const record2 of page.items)
-        records.push({ id: record2.memory.memory_id, state: subscriptionState(record2) });
+      for (const record3 of page.items)
+        records.push({ id: record3.memory.memory_id, state: subscriptionState(record3) });
       for (const failure of page.failed) failed.set(failure.memory_id, failure.version);
     };
     let resume = cursor2;
@@ -27965,7 +28433,7 @@ function createRemoteMemoryStore(options) {
       result.failed += targets.length;
       return finish();
     }
-    const writes = targets.flatMap((record2, i) => {
+    const writes = targets.flatMap((record3, i) => {
       const vector2 = vectors[i];
       if (!vector2) {
         result.failed++;
@@ -27975,11 +28443,11 @@ function createRemoteMemoryStore(options) {
         return [
           {
             memory: {
-              ...record2.memory,
+              ...record3.memory,
               embedding: storedVector(vector2),
               embedding_model: model
             },
-            expectedVersion: record2
+            expectedVersion: record3
           }
         ];
       } catch {
@@ -27994,7 +28462,7 @@ function createRemoteMemoryStore(options) {
           signal?.throwIfAborted();
           const commit = async (slice) => {
             const saved = await persistence.putMany(slice, signal, leaseToken);
-            for (const record2 of saved) repaired.add(record2.memory.memory_id);
+            for (const record3 of saved) repaired.add(record3.memory.memory_id);
             result.reembedded += saved.length;
             notify("embedding", saved);
           };
@@ -28078,7 +28546,7 @@ function createRemoteMemoryStore(options) {
       if (!topics.length) return;
       const existing = new Set((await readTopics()).map((topic2) => topic2.name));
       const missing2 = topics.flatMap((topic2) => {
-        const name = normalizeEntityName(topic2.name);
+        const name = normalizeTopicName(topic2.name);
         if (existing.has(name)) return [];
         existing.add(name);
         return [{ ...topic2, name }];
@@ -28109,7 +28577,7 @@ function createRemoteMemoryStore(options) {
           include_superseded: true
         })) {
           for (const topic2 of parseTopics(memory.topics) ?? []) {
-            const name = normalizeEntityName(topic2.name);
+            const name = normalizeTopicName(topic2.name);
             if (!name) continue;
             const entry = topics.get(name) ?? {
               name,
@@ -28147,7 +28615,7 @@ function createRemoteMemoryStore(options) {
     },
     get: async (id2) => asStored(await live2(id2)),
     listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
-      (record2) => stored(record2.memory)
+      (record3) => stored(record3.memory)
     ),
     memoriesByTopics,
     topicsByMemories: async (memoryIds) => {
@@ -28163,8 +28631,8 @@ function createRemoteMemoryStore(options) {
       return out;
     },
     create: async (input) => {
-      const record2 = await persistence.put(newRow(input), 0);
-      return created([record2], [input])[0];
+      const record3 = await persistence.put(newRow(input), 0);
+      return created([record3], [input])[0];
     },
     createMany: async (inputs) => {
       const out = [];
@@ -28251,12 +28719,12 @@ function createRemoteMemoryStore(options) {
       (memory) => memory.archived_at === void 0 || memory.archived_at === null ? { ...memory, archived_at: Date.now() } : null
     ),
     restore: (id2) => serialized(id2, async () => {
-      const record2 = await live2(id2);
-      if (!record2) return false;
-      if (record2.memory.archived_at === void 0 || record2.memory.archived_at === null)
+      const record3 = await live2(id2);
+      if (!record3) return false;
+      if (record3.memory.archived_at === void 0 || record3.memory.archived_at === null)
         return true;
-      const { archived_at: _archivedAt, ...memory } = record2.memory;
-      notify("edit", [await persistence.put(memory, record2)]);
+      const { archived_at: _archivedAt, ...memory } = record3.memory;
+      notify("edit", [await persistence.put(memory, record3)]);
       return true;
     }),
     setTopics: async (memoryId, topics) => {
@@ -28289,8 +28757,8 @@ function createRemoteMemoryStore(options) {
       const now = /* @__PURE__ */ new Date();
       return mergeTopics([], added).map(
         (topic2) => ({
-          uniqueId: normalizeEntityName(topic2.name),
-          canonicalName: normalizeEntityName(topic2.name),
+          uniqueId: normalizeTopicName(topic2.name),
+          canonicalName: normalizeTopicName(topic2.name),
           kind: topic2.kind ?? null,
           createdAt: now,
           updatedAt: now
@@ -31652,16 +32120,16 @@ var ZipProcessor = class {
     try {
       const arrayBuffer = await dataUrlToArrayBuffer(file.dataUrl);
       const zip = await JSZip.loadAsync(arrayBuffer);
-      const entries = [];
+      const entries2 = [];
       const processedContents = [];
       zip.forEach((relativePath, zipEntry) => {
-        entries.push({
+        entries2.push({
           path: relativePath,
           isDirectory: zipEntry.dir,
           zipObject: zipEntry
         });
       });
-      const visibleEntries = this.includeHidden ? entries : entries.filter((entry) => !this.isHidden(entry.path));
+      const visibleEntries = this.includeHidden ? entries2 : entries2.filter((entry) => !this.isHidden(entry.path));
       visibleEntries.sort((a, b) => {
         if (a.isDirectory !== b.isDirectory) {
           return a.isDirectory ? -1 : 1;
@@ -31775,17 +32243,17 @@ var ZipProcessor = class {
   /**
    * Format the output with file listing and processed contents
    */
-  formatOutput(entries, processedContents) {
+  formatOutput(entries2, processedContents) {
     const lines = [];
     lines.push("## Archive Contents\n");
     lines.push("```");
-    for (const entry of entries) {
+    for (const entry of entries2) {
       const icon = entry.isDirectory ? "\u{1F4C1}" : "\u{1F4C4}";
       lines.push(`${icon} ${entry.path}`);
     }
     lines.push("```\n");
-    const fileCount = entries.filter((e) => !e.isDirectory).length;
-    const dirCount = entries.filter((e) => e.isDirectory).length;
+    const fileCount = entries2.filter((e) => !e.isDirectory).length;
+    const dirCount = entries2.filter((e) => e.isDirectory).length;
     lines.push(
       `**Summary:** ${fileCount} file${fileCount !== 1 ? "s" : ""}, ${dirCount} director${dirCount !== 1 ? "ies" : "y"}
 `
@@ -32968,13 +33436,13 @@ function serializeInline(node) {
 function openTag(node, indent, depth, selfClose, maxLineWidth) {
   const head = `<${tagName(node.tag)}`;
   const tail = selfClose ? " />" : ">";
-  const entries = Object.entries(node.attrs);
-  if (entries.length === 0) return `${head}${tail}`;
-  const single = `${head} ${entries.map(([k, v]) => formatAttr(k, v)).join(" ")}${tail}`;
+  const entries2 = Object.entries(node.attrs);
+  if (entries2.length === 0) return `${head}${tail}`;
+  const single = `${head} ${entries2.map(([k, v]) => formatAttr(k, v)).join(" ")}${tail}`;
   if (single.length <= maxLineWidth) return single;
   const attrPad = indent.repeat(depth + 1);
   const closePad = indent.repeat(depth);
-  const body = entries.map(([k, v]) => `${attrPad}${formatAttr(k, v)}`).join("\n");
+  const body = entries2.map(([k, v]) => `${attrPad}${formatAttr(k, v)}`).join("\n");
   return `${head}
 ${body}
 ${closePad}${selfClose ? "/>" : ">"}`;
@@ -32986,13 +33454,13 @@ function formatAttr(name, value) {
   return `${name}={${formatObjectAttr(value)}}`;
 }
 function formatObjectAttr(obj) {
-  const entries = Object.entries(obj).map(([k, v]) => {
+  const entries2 = Object.entries(obj).map(([k, v]) => {
     const key3 = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k) ? k : JSON.stringify(k);
     if (typeof v === "string") return `${key3}: ${JSON.stringify(v)}`;
     if (typeof v === "number") return `${key3}: ${String(v)}`;
     return `${key3}: ${v ? "true" : "false"}`;
   });
-  return `{ ${entries.join(", ")} }`;
+  return `{ ${entries2.join(", ")} }`;
 }
 function isSafeJsxText(text16) {
   if (/[<>{}&]/.test(text16)) return false;
@@ -33957,6 +34425,12 @@ function cx(...classes) {
   return classes.filter(Boolean).join(" ");
 }
 var THEMES = { light: "", dark: ".dark" };
+var SAFE_CSS_KEY = /^[\w-]+$/;
+var SAFE_CSS_COLOR = /^(?:#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})|[a-z]+|(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch)\([\w\s.,%/+-]*\)|var\(--[\w-]+\))$/i;
+function isSafeCssColor(value) {
+  if (typeof value !== "string" || !SAFE_CSS_COLOR.test(value)) return false;
+  return typeof CSS === "undefined" || typeof CSS.supports !== "function" || CSS.supports("color", value);
+}
 var ChartContext = React2.createContext(null);
 function useChart() {
   const context = React2.useContext(ChartContext);
@@ -33966,7 +34440,9 @@ function useChart() {
   return context;
 }
 function ChartStyle({ id: id2, config }) {
-  const colorConfig = Object.entries(config).filter(([, cfg]) => cfg.theme || cfg.color);
+  const colorConfig = Object.entries(config).filter(
+    ([key3, cfg]) => SAFE_CSS_KEY.test(key3) && (cfg.theme || cfg.color)
+  );
   if (!colorConfig.length) return null;
   return /* @__PURE__ */ jsx2(
     "style",
@@ -33977,7 +34453,7 @@ function ChartStyle({ id: id2, config }) {
 ${prefix} [data-chart=${id2}] {
 ${colorConfig.map(([key3, itemConfig]) => {
             const color = itemConfig.theme?.[theme] || itemConfig.color;
-            return color ? `  --color-${key3}: ${color};` : null;
+            return isSafeCssColor(color) ? `  --color-${key3}: ${color};` : null;
           }).join("\n")}
 }
 `
@@ -34166,12 +34642,37 @@ var DEFAULT_COLORS = [
   "var(--chart-4)",
   "var(--chart-5)"
 ];
+function paletteColor(index) {
+  return index < DEFAULT_COLORS.length ? DEFAULT_COLORS[index] : `hsl(${Math.round(index * 137.508 % 360)} 65% 55%)`;
+}
+var compactNumber = new Intl.NumberFormat(void 0, {
+  notation: "compact",
+  maximumSignificantDigits: 3
+});
+function cellText(value) {
+  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? String(value) : "";
+}
+function formatTick(value) {
+  return typeof value === "number" ? compactNumber.format(value) : String(value);
+}
+var VISUALLY_HIDDEN = {
+  position: "absolute",
+  width: 1,
+  height: 1,
+  padding: 0,
+  margin: -1,
+  overflow: "hidden",
+  clip: "rect(0, 0, 0, 0)",
+  whiteSpace: "nowrap",
+  border: 0
+};
 function buildChartConfig(dataKeys, colors) {
   const config = {};
   dataKeys.forEach((key3, i) => {
+    const custom = colors?.[key3];
     config[key3] = {
       label: key3.charAt(0).toUpperCase() + key3.slice(1),
-      color: colors?.[key3] || DEFAULT_COLORS[i % DEFAULT_COLORS.length]
+      color: isSafeCssColor(custom) ? custom : paletteColor(i)
     };
   });
   return config;
@@ -34184,68 +34685,106 @@ function ChartCard({ data }) {
     return () => cancelAnimationFrame(frame);
   }, []);
   if ("error" in data) {
-    return /* @__PURE__ */ jsx2("div", { className: "my-4 max-w-lg", children: /* @__PURE__ */ jsx2("div", { className: "rounded-xl bg-sidebar dark:bg-card px-4 py-3", children: /* @__PURE__ */ jsx2("p", { className: "text-sm text-muted-foreground", children: data.error }) }) });
+    return /* @__PURE__ */ jsx2("div", { className: "my-4 max-w-lg", children: /* @__PURE__ */ jsx2("div", { className: "rounded-xl bg-sidebar dark:bg-card px-4 py-3", children: /* @__PURE__ */ jsx2("p", { className: "text-sm text-muted-foreground", children: "Couldn't display this chart." }) }) });
   }
   const { chartType, title, data: chartData, dataKeys, xAxisKey, colors } = data;
   const chartConfig = buildChartConfig(dataKeys, colors);
-  return /* @__PURE__ */ jsx2("div", { className: "my-4 max-w-lg", ref: containerRef, children: /* @__PURE__ */ jsxs("div", { className: "rounded-xl bg-sidebar dark:bg-card px-5 py-4", children: [
-    title && /* @__PURE__ */ jsx2("p", { className: "text-sm font-medium mb-3", children: title }),
-    ready ? /* @__PURE__ */ jsx2(ChartContainer, { config: chartConfig, className: "aspect-auto h-[250px] w-full", children: chartType === "bar" ? /* @__PURE__ */ jsxs(BarChart, { data: chartData, children: [
-      /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
-      xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
-      /* @__PURE__ */ jsx2(YAxis, { tickLine: false, axisLine: false }),
-      /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
-      dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
-      dataKeys.map((key3) => /* @__PURE__ */ jsx2(Bar, { dataKey: key3, fill: `var(--color-${key3})`, radius: 4 }, key3))
-    ] }) : chartType === "line" ? /* @__PURE__ */ jsxs(LineChart, { data: chartData, children: [
-      /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
-      xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
-      /* @__PURE__ */ jsx2(YAxis, { tickLine: false, axisLine: false }),
-      /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
-      dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
-      dataKeys.map((key3) => /* @__PURE__ */ jsx2(
-        Line2,
-        {
-          dataKey: key3,
-          stroke: `var(--color-${key3})`,
-          strokeWidth: 2,
-          dot: false
-        },
-        key3
-      ))
-    ] }) : chartType === "area" ? /* @__PURE__ */ jsxs(AreaChart, { data: chartData, children: [
-      /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
-      xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
-      /* @__PURE__ */ jsx2(YAxis, { tickLine: false, axisLine: false }),
-      /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
-      dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
-      dataKeys.map((key3) => /* @__PURE__ */ jsx2(
-        Area,
-        {
-          dataKey: key3,
-          fill: `var(--color-${key3})`,
-          stroke: `var(--color-${key3})`,
-          fillOpacity: 0.3
-        },
-        key3
-      ))
-    ] }) : /* @__PURE__ */ jsxs(PieChart, { children: [
-      /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
-      /* @__PURE__ */ jsx2(
-        Pie,
-        {
-          data: chartData,
-          dataKey: dataKeys[0],
-          nameKey: xAxisKey || "name",
-          cx: "50%",
-          cy: "50%",
-          outerRadius: 80,
-          children: chartData.map((_, index) => /* @__PURE__ */ jsx2(Cell, { fill: DEFAULT_COLORS[index % DEFAULT_COLORS.length] }, index))
-        }
-      ),
-      /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, { nameKey: xAxisKey || "name" }) })
-    ] }) }) : /* @__PURE__ */ jsx2("div", { className: "h-[250px] w-full" })
-  ] }) });
+  const seriesColor = (key3) => chartConfig[key3]?.color;
+  const longestTick = chartData.reduce(
+    (longest, point) => dataKeys.reduce((max, key3) => {
+      const value = point[key3];
+      return typeof value === "number" ? Math.max(max, formatTick(value).length) : max;
+    }, longest),
+    0
+  );
+  const yAxisProps = {
+    tickLine: false,
+    axisLine: false,
+    tickFormatter: formatTick,
+    width: Math.min(120, Math.max(40, longestTick * 7 + 16))
+  };
+  const labelKey = chartType === "pie" ? xAxisKey || "name" : xAxisKey;
+  const valueKeys = chartType === "pie" ? dataKeys.slice(0, 1) : dataKeys;
+  const tableColumns = labelKey ? [labelKey, ...valueKeys] : valueKeys;
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: "my-4 max-w-lg",
+      ref: containerRef,
+      role: "figure",
+      "aria-label": [title, `${chartType} chart`].filter(Boolean).join(", "),
+      children: /* @__PURE__ */ jsxs("div", { className: "rounded-xl bg-sidebar dark:bg-card px-5 py-4", children: [
+        title && /* @__PURE__ */ jsx2("p", { className: "text-sm font-medium mb-3", children: title }),
+        /* @__PURE__ */ jsxs("table", { style: VISUALLY_HIDDEN, children: [
+          /* @__PURE__ */ jsx2("thead", { children: /* @__PURE__ */ jsx2("tr", { children: tableColumns.map((column) => /* @__PURE__ */ jsx2("th", { scope: "col", children: column }, column)) }) }),
+          /* @__PURE__ */ jsx2("tbody", { children: chartData.map((point, row) => /* @__PURE__ */ jsx2("tr", { children: tableColumns.map((column) => /* @__PURE__ */ jsx2("td", { children: cellText(point[column]) }, column)) }, row)) })
+        ] }),
+        ready ? /* @__PURE__ */ jsx2(
+          ChartContainer,
+          {
+            config: chartConfig,
+            className: "aspect-auto h-[250px] w-full",
+            "aria-hidden": "true",
+            children: chartType === "bar" ? /* @__PURE__ */ jsxs(BarChart, { data: chartData, children: [
+              /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
+              xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
+              /* @__PURE__ */ jsx2(YAxis, { ...yAxisProps }),
+              /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
+              dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
+              dataKeys.map((key3) => /* @__PURE__ */ jsx2(Bar, { dataKey: key3, fill: seriesColor(key3), radius: 4 }, key3))
+            ] }) : chartType === "line" ? /* @__PURE__ */ jsxs(LineChart, { data: chartData, children: [
+              /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
+              xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
+              /* @__PURE__ */ jsx2(YAxis, { ...yAxisProps }),
+              /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
+              dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
+              dataKeys.map((key3) => /* @__PURE__ */ jsx2(
+                Line2,
+                {
+                  dataKey: key3,
+                  stroke: seriesColor(key3),
+                  strokeWidth: 2,
+                  dot: false
+                },
+                key3
+              ))
+            ] }) : chartType === "area" ? /* @__PURE__ */ jsxs(AreaChart, { data: chartData, children: [
+              /* @__PURE__ */ jsx2(CartesianGrid, { vertical: false }),
+              xAxisKey && /* @__PURE__ */ jsx2(XAxis, { dataKey: xAxisKey, tickLine: false, axisLine: false, tickMargin: 8 }),
+              /* @__PURE__ */ jsx2(YAxis, { ...yAxisProps }),
+              /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
+              dataKeys.length > 1 && /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, {}) }),
+              dataKeys.map((key3) => /* @__PURE__ */ jsx2(
+                Area,
+                {
+                  dataKey: key3,
+                  fill: seriesColor(key3),
+                  stroke: seriesColor(key3),
+                  fillOpacity: 0.3
+                },
+                key3
+              ))
+            ] }) : /* @__PURE__ */ jsxs(PieChart, { children: [
+              /* @__PURE__ */ jsx2(ChartTooltip, { content: /* @__PURE__ */ jsx2(ChartTooltipContent, {}) }),
+              /* @__PURE__ */ jsx2(
+                Pie,
+                {
+                  data: chartData,
+                  dataKey: dataKeys[0],
+                  nameKey: xAxisKey || "name",
+                  cx: "50%",
+                  cy: "50%",
+                  outerRadius: 80,
+                  children: chartData.map((_, index) => /* @__PURE__ */ jsx2(Cell, { fill: paletteColor(index) }, index))
+                }
+              ),
+              /* @__PURE__ */ jsx2(ChartLegend, { content: /* @__PURE__ */ jsx2(ChartLegendContent, { nameKey: xAxisKey || "name" }) })
+            ] })
+          }
+        ) : /* @__PURE__ */ jsx2("div", { className: "h-[250px] w-full" })
+      ] })
+    }
+  );
 }
 
 // src/react/LoggerProvider.tsx
@@ -34390,7 +34929,7 @@ async function uploadFileToICloud(filename, content, backupRevision) {
   const recordName = `backup_${filename.replace(/[^a-zA-Z0-9]/g, "_")}`;
   const arrayBuffer = await content.arrayBuffer();
   const base64Data = uint8ArrayToBase64(new Uint8Array(arrayBuffer));
-  const record2 = {
+  const record3 = {
     recordType: RECORD_TYPE,
     recordName,
     fields: {
@@ -34401,7 +34940,7 @@ async function uploadFileToICloud(filename, content, backupRevision) {
       ...backupRevision ? { backupRevision: { value: backupRevision } } : {}
     }
   };
-  const response = await database.saveRecords(record2);
+  const response = await database.saveRecords(record3);
   if (!response.records || response.records.length === 0) {
     throw new Error("Failed to upload file to iCloud");
   }
@@ -34428,12 +34967,12 @@ async function listICloudFiles() {
   while (response.continuationMarker) {
     break;
   }
-  const files = allRecords.map((record2) => ({
-    recordName: record2.recordName,
-    filename: record2.fields.filename?.value ?? "",
-    modifiedAt: new Date(record2.modified?.timestamp ?? Date.now()),
-    backupRevision: record2.fields.backupRevision?.value,
-    size: typeof record2.fields.data?.value === "object" && record2.fields.data?.value !== null ? record2.fields.data.value.size : 0
+  const files = allRecords.map((record3) => ({
+    recordName: record3.recordName,
+    filename: record3.fields.filename?.value ?? "",
+    modifiedAt: new Date(record3.modified?.timestamp ?? Date.now()),
+    backupRevision: record3.fields.backupRevision?.value,
+    size: typeof record3.fields.data?.value === "object" && record3.fields.data?.value !== null ? record3.fields.data.value.size : 0
   }));
   return files.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime());
 }
@@ -34446,8 +34985,8 @@ async function downloadICloudFile(recordName) {
   if (!response.records || response.records.length === 0) {
     throw new Error(`File not found: ${recordName}`);
   }
-  const record2 = response.records[0];
-  const dataField = record2.fields.data?.value;
+  const record3 = response.records[0];
+  const dataField = record3.fields.data?.value;
   if (!dataField) {
     throw new Error("No data in record");
   }
@@ -34481,13 +35020,13 @@ async function findICloudFile(filename) {
   if (!response.records || response.records.length === 0) {
     return null;
   }
-  const record2 = response.records[0];
+  const record3 = response.records[0];
   return {
-    recordName: record2.recordName,
-    filename: record2.fields.filename?.value ?? "",
-    modifiedAt: new Date(record2.modified?.timestamp ?? Date.now()),
-    backupRevision: record2.fields.backupRevision?.value,
-    size: typeof record2.fields.data?.value === "object" && record2.fields.data?.value !== null ? record2.fields.data.value.size : 0
+    recordName: record3.recordName,
+    filename: record3.fields.filename?.value ?? "",
+    modifiedAt: new Date(record3.modified?.timestamp ?? Date.now()),
+    backupRevision: record3.fields.backupRevision?.value,
+    size: typeof record3.fields.data?.value === "object" && record3.fields.data?.value !== null ? record3.fields.data.value.size : 0
   };
 }
 
@@ -35837,13 +36376,13 @@ function useConversationRedactors(database, account, storage, secondaryStorage)
   return useCallback4(
     (conversationId, nerDetector) => {
       if (!scope.active) return retiredRedactor;
-      const cached = scope.redactors.get(conversationId);
-      if (cached && cached.detector === nerDetector) {
+      const cached2 = scope.redactors.get(conversationId);
+      if (cached2 && cached2.detector === nerDetector) {
         scope.redactors.delete(conversationId);
-        scope.redactors.set(conversationId, cached);
-        return cached.redactor;
+        scope.redactors.set(conversationId, cached2);
+        return cached2.redactor;
       }
-      if (cached) scope.evicted.push(cached.redactor);
+      if (cached2) scope.evicted.push(cached2.redactor);
       const redactor = new PiiRedactor({ nerDetector });
       scope.redactors.set(conversationId, { redactor, detector: nerDetector });
       if (scope.redactors.size > REDACTOR_LIMIT) {
@@ -39338,11 +39877,11 @@ async function fetchAllModelPages(baseUrl, provider, headers, previous, signal)
   return { pages, models, fetchedAt: Date.now() };
 }
 function loadModels(key3, baseUrl, provider, headers, force, signal) {
-  const cached = modelsCache.get(key3);
-  if (cached && !force && Date.now() - cached.fetchedAt < MODELS_CACHE_TTL_MS) {
-    return Promise.resolve([...cached.models]);
+  const cached2 = modelsCache.get(key3);
+  if (cached2 && !force && Date.now() - cached2.fetchedAt < MODELS_CACHE_TTL_MS) {
+    return Promise.resolve([...cached2.models]);
   }
-  const shared = (force ? void 0 : modelsInFlight.get(key3)) ?? startSharedRequest(key3, baseUrl, provider, headers, cached);
+  const shared = (force ? void 0 : modelsInFlight.get(key3)) ?? startSharedRequest(key3, baseUrl, provider, headers, cached2);
   return waitForSharedRequest(key3, shared, signal).then((models) => [...models]);
 }
 function startSharedRequest(key3, baseUrl, provider, headers, previous) {
@@ -40195,20 +40734,20 @@ function startObserve(entry, walletAddress) {
     "updated_at"
   ]).subscribe({
     next: (records) => {
-      const record2 = records[0];
-      if (!record2) return;
+      const record3 = records[0];
+      if (!record3) return;
       const patch = {
         userPreference: {
-          uniqueId: record2.id,
-          walletAddress: record2.walletAddress,
-          nickname: record2.nickname,
-          occupation: record2.occupation,
-          description: record2.description,
-          models: record2.models,
-          personality: record2.personality,
-          externalWallets: record2.externalWallets,
-          createdAt: record2.createdAt,
-          updatedAt: record2.updatedAt
+          uniqueId: record3.id,
+          walletAddress: record3.walletAddress,
+          nickname: record3.nickname,
+          occupation: record3.occupation,
+          description: record3.description,
+          models: record3.models,
+          personality: record3.personality,
+          externalWallets: record3.externalWallets,
+          createdAt: record3.createdAt,
+          updatedAt: record3.updatedAt
         }
       };
       if (isInitialEmission) {