@anuma/sdk 6.34.0 → 6.36.0

package/dist/react/index.mjs

@@ -89,9 +89,9 @@ function createSseClient({
             if (done) break;
             buffer += value;
             buffer = buffer.replace(/\r\n?/g, "\n");
-            const chunks = buffer.split("\n\n");
-            buffer = chunks.pop() ?? "";
-            for (const chunk of chunks) {
+            const chunks2 = buffer.split("\n\n");
+            buffer = chunks2.pop() ?? "";
+            for (const chunk of chunks2) {
               const lines = chunk.split("\n");
               const dataLines = [];
               let eventName;
@@ -4731,14 +4731,14 @@ async function updateMessageEmbeddingOp(ctx, uniqueId, vector, embeddingModel) {
   });
   return messageToStored(message, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
-async function updateMessageChunksOp(ctx, uniqueId, chunks, embeddingModel) {
+async function updateMessageChunksOp(ctx, uniqueId, chunks2, embeddingModel) {
   let message;
   try {
     message = await ctx.messagesCollection.find(uniqueId);
   } catch {
     return null;
   }
-  const storedChunks = chunks.map(({ text: _text, ...rest }) => rest);
+  const storedChunks = chunks2.map(({ text: _text, ...rest }) => rest);
   await ctx.database.write(async () => {
     await message.update((msg) => {
       msg._setRaw("chunks", JSON.stringify(storedChunks));
@@ -4782,12 +4782,12 @@ async function stripLegacyChunkTextOp(ctx) {
       const messages = await ctx.messagesCollection.query(Q.where("id", Q.oneOf(changedIds))).fetch();
       const updates = messages.flatMap((message) => {
         const raw = message._raw;
-        const chunks = chunksWithoutText(raw.chunks);
-        if (!chunks) return [];
+        const chunks2 = chunksWithoutText(raw.chunks);
+        if (!chunks2) return [];
         const updatedAt = raw.updated_at;
         return [
           message.prepareUpdate((msg) => {
-            msg._setRaw("chunks", JSON.stringify(chunks));
+            msg._setRaw("chunks", JSON.stringify(chunks2));
             msg._setRaw("updated_at", updatedAt);
           })
         ];
@@ -4997,15 +4997,15 @@ async function searchChunksOp(ctx, queryVector, options) {
       }
       continue;
     }
-    const chunks = await readRawJsonField(message, "chunks", ctx.walletAddress);
-    if (chunks && chunks.length > 0) {
-      const vectors = chunks.map(
+    const chunks2 = await readRawJsonField(message, "chunks", ctx.walletAddress);
+    if (chunks2 && chunks2.length > 0) {
+      const vectors = chunks2.map(
         (chunk) => decodeChunkVector(chunk.vector, () => {
           unreadableVectors++;
         })
       );
       chunkCache?.set(message.id, { version, chunks: vectors });
-      for (let ci = 0; ci < chunks.length; ci++) {
+      for (let ci = 0; ci < chunks2.length; ci++) {
         const vec = vectors[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
@@ -5013,7 +5013,7 @@ async function searchChunksOp(ctx, queryVector, options) {
           candidates.push({
             message,
             similarity,
-            chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+            chunkTextSource: { kind: "chunk", chunk: chunks2[ci], siblings: chunks2 }
           });
         }
       }
@@ -5190,7 +5190,7 @@ function chunkText(text12, options) {
     ];
   }
   const sentences = splitIntoSentences(text12);
-  const chunks = [];
+  const chunks2 = [];
   let currentChunkSentences = [];
   let currentChunkStart = 0;
   let currentOffset = 0;
@@ -5204,7 +5204,7 @@ function chunkText(text12, options) {
     if (sentence.length > chunkSize) {
       if (currentChunkSentences.length > 0) {
         const chunkText2 = currentChunkSentences.join(" ");
-        chunks.push({
+        chunks2.push({
           text: chunkText2,
           startOffset: currentChunkStart,
           endOffset: currentOffset
@@ -5215,7 +5215,7 @@ function chunkText(text12, options) {
         const chunkEnd = Math.min(j + chunkSize, sentence.length);
         const chunk = sentence.slice(j, chunkEnd);
         if (chunk.length >= minChunkSize) {
-          chunks.push({
+          chunks2.push({
             text: chunk,
             startOffset: sentenceStart + j,
             endOffset: sentenceStart + chunkEnd
@@ -5229,7 +5229,7 @@ function chunkText(text12, options) {
     const currentText = currentChunkSentences.join(" ");
     const potentialLength = currentText.length + (currentText ? 1 : 0) + sentence.length;
     if (potentialLength > chunkSize && currentChunkSentences.length > 0) {
-      chunks.push({
+      chunks2.push({
         text: currentText,
         startOffset: currentChunkStart,
         endOffset: currentOffset
@@ -5260,14 +5260,14 @@ function chunkText(text12, options) {
   if (currentChunkSentences.length > 0) {
     const chunkText2 = currentChunkSentences.join(" ");
     if (chunkText2.length >= minChunkSize) {
-      chunks.push({
+      chunks2.push({
         text: chunkText2,
         startOffset: currentChunkStart,
         endOffset: text12.length
       });
     }
   }
-  if (chunks.length === 0) {
+  if (chunks2.length === 0) {
     const trimmedText = text12.trim();
     if (trimmedText.length > 0) {
       return [
@@ -5279,7 +5279,7 @@ function chunkText(text12, options) {
       ];
     }
   }
-  return chunks;
+  return chunks2;
 }
 function shouldChunkMessage(content, chunkSize = DEFAULT_CHUNK_SIZE) {
   return content.length > chunkSize;
@@ -5497,18 +5497,18 @@ async function embedMany(texts, options, outer) {
       outer
     );
   } else {
-    const chunks = [];
+    const chunks2 = [];
     for (let i = 0; i < uncachedTexts.length; i += chunkSize) {
-      chunks.push(uncachedTexts.slice(i, i + chunkSize));
+      chunks2.push(uncachedTexts.slice(i, i + chunkSize));
     }
-    const allEmbeddings = new Array(chunks.length);
+    const allEmbeddings = new Array(chunks2.length);
     let nextIndex = 0;
     const worker = async () => {
-      while (nextIndex < chunks.length) {
+      while (nextIndex < chunks2.length) {
         if (outer?.aborted) throw outer.reason;
         const idx = nextIndex++;
         allEmbeddings[idx] = await generateEmbeddingsBatch(
-          chunks[idx],
+          chunks2[idx],
           headers,
           baseUrl,
           embeddingModel,
@@ -5520,7 +5520,7 @@ async function embedMany(texts, options, outer) {
       }
     };
     const workers = Array.from(
-      { length: Math.min(DEFAULT_EMBEDDING_BATCH_CONCURRENCY, chunks.length) },
+      { length: Math.min(DEFAULT_EMBEDDING_BATCH_CONCURRENCY, chunks2.length) },
       () => worker()
     );
     await Promise.all(workers);
@@ -11318,6 +11318,15 @@ __decorateClass([
 __decorateClass([
   text6("scope")
 ], VaultMemory.prototype, "scope", 2);
+__decorateClass([
+  field5("kind")
+], VaultMemory.prototype, "kind", 2);
+__decorateClass([
+  field5("kind_value")
+], VaultMemory.prototype, "kindValue", 2);
+__decorateClass([
+  field5("level")
+], VaultMemory.prototype, "level", 2);
 __decorateClass([
   field5("folder_id")
 ], VaultMemory.prototype, "folderId", 2);
@@ -11543,7 +11552,7 @@ __decorateClass([
 ], VaultFolder.prototype, "context", 2);
 
 // src/lib/db/schema.ts
-var SDK_SCHEMA_VERSION = 47;
+var SDK_SCHEMA_VERSION = 48;
 var sdkSchema = appSchema2({
   version: SDK_SCHEMA_VERSION,
   tables: [
@@ -11638,6 +11647,9 @@ var sdkSchema = appSchema2({
       columns: [
         { name: "content", type: "string" },
         { name: "scope", type: "string", isIndexed: true },
+        { name: "kind", type: "string", isOptional: true, isIndexed: true },
+        { name: "kind_value", type: "string", isOptional: true },
+        { name: "level", type: "string", isOptional: true, isIndexed: true },
         { name: "folder_id", type: "string", isOptional: true, isIndexed: true },
         { name: "created_at", type: "number", isIndexed: true },
         { name: "updated_at", type: "number", isIndexed: true },
@@ -12314,6 +12326,22 @@ var sdkMigrations = schemaMigrations2({
           ]
         })
       ]
+    },
+    {
+      toVersion: 48,
+      steps: [
+        addColumns2({
+          table: "memory_vault",
+          columns: [
+            { name: "kind", type: "string", isOptional: true, isIndexed: true },
+            { name: "kind_value", type: "string", isOptional: true },
+            { name: "level", type: "string", isOptional: true, isIndexed: true }
+          ]
+        }),
+        unsafeExecuteSql(
+          "UPDATE memory_vault SET level = CASE WHEN scope IN ('shared', 'public') THEN 'matching' ELSE 'private' END WHERE level IS NULL;"
+        )
+      ]
     }
   ]
 });
@@ -12835,8 +12863,8 @@ var WatermelonChatStorageAdapter = class {
   updateMessageEmbedding(uniqueId, vector, embeddingModel) {
     return updateMessageEmbeddingOp(this.ctx, uniqueId, vector, embeddingModel);
   }
-  updateMessageChunks(uniqueId, chunks, embeddingModel) {
-    return updateMessageChunksOp(this.ctx, uniqueId, chunks, embeddingModel);
+  updateMessageChunks(uniqueId, chunks2, embeddingModel) {
+    return updateMessageChunksOp(this.ctx, uniqueId, chunks2, embeddingModel);
   }
   updateMessageError(uniqueId, error) {
     return updateMessageErrorOp(this.ctx, uniqueId, error);
@@ -13450,13 +13478,54 @@ async function decryptVaultMemoryFields(memory, address, signMessage, embeddedWa
     }
   }
   const decryptedContent = await decryptField(memory.content, address);
+  const decryptedKindValue = typeof memory.kindValue === "string" ? await decryptField(memory.kindValue, address) : memory.kindValue;
   return {
     ...memory,
-    content: decryptedContent
+    content: decryptedContent,
+    ...decryptedKindValue !== void 0 && { kindValue: decryptedKindValue }
   };
 }
 
 // src/lib/db/memoryVault/types.ts
+var MEMORY_KINDS = [
+  "display_name",
+  "birth_date",
+  "bio",
+  "occupation",
+  "interest",
+  "gender",
+  "height_cm",
+  "looking_for",
+  "politics",
+  "religion",
+  "ethnicity",
+  "smoking",
+  "drinking",
+  "exercise",
+  "sexuality",
+  "prompt"
+];
+var MEMORY_LEVELS = ["private", "matching", "profile"];
+var MemoryLevelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryLevelError";
+  }
+};
+var PUBLISHED_SCOPES = /* @__PURE__ */ new Set(["shared", "public"]);
+function levelFromScope(scope) {
+  return typeof scope === "string" && PUBLISHED_SCOPES.has(scope) ? "matching" : "private";
+}
+function scopeForLevel(level) {
+  return level === "private" ? "private" : "shared";
+}
+function resolveMemoryLevel(level, scope) {
+  return typeof level === "string" && MEMORY_LEVELS.includes(level) ? level : levelFromScope(scope);
+}
+function levelForScopeChange(current, nextScope) {
+  const implied = levelFromScope(nextScope);
+  return implied === "matching" && resolveMemoryLevel(current.level, current.scope) === "profile" ? "profile" : implied;
+}
 function parseMedia(value) {
   if (typeof value !== "string" || value === "") return null;
   try {
@@ -13486,6 +13555,56 @@ function visibilityConditions(requested) {
   if (excluded.length === 0) return [];
   return [Q8.or(Q8.where("visibility", null), Q8.where("visibility", Q8.notIn(excluded)))];
 }
+function isKinded(record2) {
+  return record2.kind !== null && record2.kind !== void 0;
+}
+function assertValidKindLevel(kind, level) {
+  const hasKind = kind !== null && kind !== void 0;
+  if (hasKind && !MEMORY_KINDS.includes(kind)) {
+    throw new MemoryLevelError(`Unknown memory kind: ${kind}`);
+  }
+  if (level !== void 0 && !MEMORY_LEVELS.includes(level)) {
+    throw new MemoryLevelError(`Unknown memory level: ${level}`);
+  }
+  if (level === "profile" && !hasKind) {
+    throw new MemoryLevelError("Only a memory with a kind can be at level 'profile'");
+  }
+}
+function resolveCreateLevel(opts) {
+  if (opts.level !== void 0) return { level: opts.level, scope: scopeForLevel(opts.level) };
+  if (opts.scope !== void 0) return { level: levelFromScope(opts.scope), scope: opts.scope };
+  return { level: "private", scope: "private" };
+}
+async function encryptKindValue(ctx, value) {
+  if (typeof value !== "string" || !ctx.walletAddress || !ctx.signMessage) return value;
+  return encryptVaultMemoryContent(
+    value,
+    ctx.walletAddress,
+    ctx.signMessage,
+    ctx.embeddedWalletSigner
+  );
+}
+function levelConditions(requested) {
+  if (!requested?.length) return [];
+  const published = ["shared", "public"];
+  const wantsMatching = requested.includes("matching");
+  const wantsPrivate = requested.includes("private");
+  const unresolved = Q8.or(Q8.where("level", null), Q8.where("level", Q8.notIn([...MEMORY_LEVELS])));
+  const byLevel = Q8.where("level", Q8.oneOf([...requested]));
+  if (wantsMatching && wantsPrivate) return [Q8.or(byLevel, unresolved)];
+  if (wantsMatching) {
+    return [Q8.or(byLevel, Q8.and(unresolved, Q8.where("scope", Q8.oneOf(published))))];
+  }
+  if (wantsPrivate) {
+    return [
+      Q8.or(
+        byLevel,
+        Q8.and(unresolved, Q8.or(Q8.where("scope", null), Q8.where("scope", Q8.notIn(published))))
+      )
+    ];
+  }
+  return [byLevel];
+}
 function isOwnedByCtxUser(ctx, record2) {
   return ctx.userId === void 0 || record2.userId === ctx.userId;
 }
@@ -13529,6 +13648,9 @@ function vaultMemoryToStoredRaw(memory) {
     uniqueId: memory.id,
     content: memory.content,
     scope: memory.scope,
+    kind: memory.kind ?? null,
+    kindValue: memory.kindValue ?? null,
+    level: resolveMemoryLevel(memory.level, memory.scope),
     folderId: memory.folderId ?? null,
     userId: memory.userId ?? null,
     embedding: memory.embedding ?? null,
@@ -13567,9 +13689,13 @@ async function vaultMemoryToStored(memory, walletAddress, signMessage, embeddedW
   }
   return raw;
 }
-function populateNewVaultMemory(record2, ctx, opts, encryptedContent) {
+function populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue) {
+  const { level, scope } = resolveCreateLevel(opts);
   record2._setRaw("content", encryptedContent);
-  record2._setRaw("scope", opts.scope ?? "private");
+  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);
@@ -13603,6 +13729,8 @@ function populateNewVaultMemory(record2, ctx, opts, encryptedContent) {
   }
 }
 async function createVaultMemoryOp(ctx, opts) {
+  assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -13613,13 +13741,15 @@ async function createVaultMemoryOp(ctx, opts) {
     if (ctx.canWrite && !await ctx.canWrite())
       throw new Error("Memory source is no longer eligible");
     return ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent)
+      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
     );
   });
   return vaultMemoryToStored(created, ctx.walletAddress, ctx.signMessage, ctx.embeddedWalletSigner);
 }
 async function createSupersedingMemoryOp(ctx, opts, targetId) {
   if (!targetId) return { created: null, retired: false };
+  assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
   const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
     opts.content,
     ctx.walletAddress,
@@ -13636,9 +13766,10 @@ async function createSupersedingMemoryOp(ctx, opts, targetId) {
     } catch {
       return;
     }
-    if (target.isDeleted || target.supersededBy || !isOwnedByCtxUser(ctx, target)) return;
+    if (target.isDeleted || target.supersededBy || isKinded(target) || !isOwnedByCtxUser(ctx, target))
+      return;
     createdRecord = await ctx.vaultMemoryCollection.create(
-      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent)
+      (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContent, encryptedKindValue)
     );
     await target.update((r) => {
       r._setRaw("superseded_by", createdRecord.id);
@@ -13702,6 +13833,10 @@ async function getMemoriesByEventTimeOp(ctx, windowStart, windowEnd) {
 }
 async function createVaultMemoriesBatchOp(ctx, optionsArray) {
   if (optionsArray.length === 0) return [];
+  for (const opts of optionsArray) assertValidKindLevel(opts.kind, resolveCreateLevel(opts).level);
+  const encryptedKindValues = await Promise.all(
+    optionsArray.map((opts) => encryptKindValue(ctx, opts.kindValue))
+  );
   const encryptedContents = await Promise.all(
     optionsArray.map(async (opts) => {
       if (ctx.walletAddress && ctx.signMessage) {
@@ -13720,7 +13855,7 @@ async function createVaultMemoriesBatchOp(ctx, optionsArray) {
       throw new Error("Memory source is no longer eligible");
     const prepared = optionsArray.map(
       (opts, i) => ctx.vaultMemoryCollection.prepareCreate(
-        (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i])
+        (record2) => populateNewVaultMemory(record2, ctx, opts, encryptedContents[i], encryptedKindValues[i])
       )
     );
     await ctx.database.batch(...prepared);
@@ -13763,6 +13898,9 @@ function vaultMemoryRawToStoredRaw(raw) {
     uniqueId: raw.id,
     content: raw.content ?? "",
     scope: raw.scope ?? "",
+    kind: raw.kind ?? null,
+    kindValue: raw.kind_value ?? null,
+    level: resolveMemoryLevel(raw.level, raw.scope),
     folderId: raw.folder_id ?? null,
     userId: raw.user_id ?? null,
     embedding: raw.embedding ?? null,
@@ -13806,6 +13944,8 @@ async function getAllVaultMemoriesOp(ctx, options) {
     ...baseVaultConditions(ctx, options),
     ...options?.scopes?.length ? [Q8.where("scope", Q8.oneOf(options.scopes))] : [],
     ...visibilityConditions(options?.visibility),
+    ...levelConditions(options?.levels),
+    ...options?.kinds?.length ? [Q8.where("kind", Q8.oneOf(options.kinds))] : [],
     ...options?.folderId !== void 0 ? [Q8.where("folder_id", options.folderId)] : [],
     ...options?.factTypes?.length ? [Q8.where("fact_type", Q8.oneOf(options.factTypes))] : [],
     Q8.sortBy(options?.since ? "updated_at" : "created_at", Q8.desc),
@@ -13972,6 +14112,14 @@ async function updateVaultMemoryOp(ctx, id, opts) {
   try {
     const probe = await ctx.vaultMemoryCollection.find(id);
     if (probe.isDeleted || probe.supersededBy || !isOwnedByCtxUser(ctx, probe)) return null;
+    if (opts.freeFormOnly && isKinded(probe)) return null;
+    const levelAfter = (current) => {
+      if (opts.level !== void 0) return opts.level;
+      if (opts.scope === void 0) return resolveMemoryLevel(current.level, current.scope);
+      return levelForScopeChange(current, opts.scope);
+    };
+    assertValidKindLevel(opts.kind !== void 0 ? opts.kind : probe.kind, levelAfter(probe));
+    const encryptedKindValue = await encryptKindValue(ctx, opts.kindValue);
     const encryptedContent = ctx.walletAddress && ctx.signMessage ? await encryptVaultMemoryContent(
       opts.content,
       ctx.walletAddress,
@@ -13984,10 +14132,13 @@ async function updateVaultMemoryOp(ctx, id, opts) {
     await ctx.database.write(async () => {
       if (ctx.canWrite && !await ctx.canWrite())
         throw new Error("Memory source is no longer eligible");
-      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) {
+      if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2) || opts.freeFormOnly && isKinded(record2)) {
         stale = true;
         return;
       }
+      const nextKind = opts.kind !== void 0 ? opts.kind : record2.kind;
+      const nextLevel = levelAfter(record2);
+      assertValidKindLevel(nextKind, nextLevel);
       let observedSources = [];
       let replayedObservation = false;
       if (opts.observationSourceIds?.length) {
@@ -14001,8 +14152,18 @@ async function updateVaultMemoryOp(ctx, id, opts) {
       }
       await record2.update((r) => {
         r._setRaw("content", encryptedContent);
-        if (opts.scope !== void 0) {
+        if (opts.level !== void 0) {
+          r._setRaw("level", nextLevel);
+          r._setRaw("scope", scopeForLevel(nextLevel));
+        } else if (opts.scope !== void 0) {
           r._setRaw("scope", opts.scope);
+          r._setRaw("level", nextLevel);
+        }
+        if (opts.kind !== void 0) {
+          r._setRaw("kind", opts.kind);
+        }
+        if (encryptedKindValue !== void 0) {
+          r._setRaw("kind_value", encryptedKindValue);
         }
         if (opts.folderId !== void 0) {
           r._setRaw("folder_id", opts.folderId);
@@ -14061,7 +14222,8 @@ async function updateVaultMemoryOp(ctx, id, opts) {
       ctx.signMessage,
       ctx.embeddedWalletSigner
     );
-  } catch {
+  } catch (err) {
+    if (err instanceof MemoryLevelError) throw err;
     return null;
   }
 }
@@ -14197,6 +14359,7 @@ async function supersedeVaultMemoryOp(ctx, id, supersededById) {
   try {
     const record2 = await ctx.vaultMemoryCollection.find(id);
     if (record2.isDeleted || record2.supersededBy || !isOwnedByCtxUser(ctx, record2)) return false;
+    if (isKinded(record2)) return false;
     let successor;
     try {
       successor = await ctx.vaultMemoryCollection.find(supersededById);
@@ -14497,7 +14660,10 @@ function assertVaultScopeForSweep(ctx) {
 }
 async function getDecayCandidatesRawOp(ctx) {
   assertVaultScopeForSweep(ctx);
-  const results = await ctx.vaultMemoryCollection.query(...baseVaultConditions(ctx, { includeArchived: true, includeQuarantined: true })).unsafeFetchRaw();
+  const results = await ctx.vaultMemoryCollection.query(
+    ...baseVaultConditions(ctx, { includeArchived: true, includeQuarantined: true }),
+    Q8.where("kind", null)
+  ).unsafeFetchRaw();
   return results.map((raw) => ({
     uniqueId: raw.id,
     factType: raw.fact_type ?? null,
@@ -14757,6 +14923,7 @@ async function ingestPublishedPhotoMemoriesOp(ctx, rows) {
         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);
@@ -15622,6 +15789,7 @@ async function updateVaultFolderOp(ctx, id, opts) {
       for (const memory of memories) {
         updates.push(
           memory.prepareUpdate((r) => {
+            r._setRaw("level", levelForScopeChange(r, opts.scope));
             r._setRaw("scope", opts.scope);
           })
         );
@@ -15643,6 +15811,7 @@ async function deleteVaultFolderOp(ctx, id) {
       const preparedMemories = memories.map(
         (memory) => memory.prepareUpdate((r) => {
           r._setRaw("folder_id", null);
+          r._setRaw("level", levelForScopeChange(r, "private"));
           r._setRaw("scope", "private");
         })
       );
@@ -15679,6 +15848,7 @@ async function moveMemoriesToFolderOp(ctx, memoryIds, folderId) {
       const prepared = memories.map(
         (memory) => memory.prepareUpdate((r) => {
           r._setRaw("folder_id", folderId);
+          r._setRaw("level", levelForScopeChange(r, targetScope));
           r._setRaw("scope", targetScope);
         })
       );
@@ -17986,6 +18156,7 @@ async function retainWithPersistence(content, ctx, options = {}) {
       includeArchived: true,
       ...options.folderId !== void 0 && { folderId: options.folderId }
     });
+    prepared = withoutKindedRows(prepared);
     if (prepared.embeddingFailure || prepared.embeddingsUnavailable) {
       throw new Error(
         "retain: embeddings unavailable \u2014 refusing to auto-merge against an inert cosine lane, which would create a duplicate instead of merging into the existing memory. Retry when embeddings recover, or pass enableAutoMerge: false to force a create."
@@ -18027,6 +18198,7 @@ async function retainWithPersistence(content, ctx, options = {}) {
           const resurrect = resurrectFields(existing);
           const updated = await ctx.persistence.update(targetId, {
             content: existing.content,
+            freeFormOnly: true,
             proofCountIncrement: 1,
             observationSourceIds: options.sourceChunkIds,
             sourceChunkIds: mergedSourceIds,
@@ -18155,6 +18327,17 @@ async function retainWithPersistence(content, ctx, options = {}) {
     ...consolidationDecidedCreate && { consolidation: "create" }
   };
 }
+function withoutKindedRows(prepared) {
+  const kinded = new Set(
+    prepared.memories.filter((m) => m.kind !== null && m.kind !== void 0).map((m) => m.uniqueId)
+  );
+  if (kinded.size === 0) return prepared;
+  return {
+    ...prepared,
+    memories: prepared.memories.filter((m) => !kinded.has(m.uniqueId)),
+    embeddedItems: prepared.embeddedItems.filter((item) => !kinded.has(item.id))
+  };
+}
 function unionStrings(a, b) {
   return [.../* @__PURE__ */ new Set([...a, ...b])];
 }
@@ -18254,6 +18437,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     const resurrect = resurrectFields(existing);
     const updated = await ctx.persistence.update(decision.targetId, {
       content: existing.content,
+      freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
       sourceChunkIds: mergedSourceIds,
@@ -18299,6 +18483,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
     const resurrect = resurrectFields(existing);
     const updated = await ctx.persistence.update(decision.targetId, {
       content: decision.content,
+      freeFormOnly: true,
       proofCountIncrement: 1,
       observationSourceIds: options.sourceChunkIds,
       sourceChunkIds: mergedSourceIds,
@@ -18342,7 +18527,7 @@ async function tryConsolidate(trimmed, ctx, options, prepared) {
 }
 async function assertMergeTargetGoneOrThrow(ctx, targetId) {
   const stillExists = await (ctx.persistence.getFresh ? ctx.persistence.getFresh(targetId) : ctx.persistence.get(targetId));
-  if (stillExists) {
+  if (stillExists && (stillExists.kind === null || stillExists.kind === void 0)) {
     throw new Error(`retain: merge into memory ${targetId} failed to persist`);
   }
 }
@@ -20984,6 +21169,65 @@ function createLocalMemoryStore(options) {
   };
 }
 
+// src/lib/memory/store/memoryKeys.ts
+var KEY_ID_DOMAIN = "anuma-private-memory-key-id-v1";
+var MemoryKeyError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MemoryKeyError";
+  }
+};
+async function importAesKey(hex) {
+  return crypto.subtle.importKey(
+    "raw",
+    hexToBytes(hex).buffer,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function deriveMemoryKeyRing(signatureHex) {
+  const v3Hex = await deriveKeyFromSignatureV3(signatureHex);
+  const digest = await crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(`${KEY_ID_DOMAIN}:${v3Hex}`)
+  );
+  const keyId = "v3:" + Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+  return {
+    keyId,
+    v3: await importAesKey(v3Hex),
+    v2: await importAesKey(await deriveKeyFromSignature(signatureHex))
+  };
+}
+async function decryptWith(value, rings) {
+  const version = value.startsWith("enc:v3:") ? "v3" : "v2";
+  for (const ring of rings) {
+    try {
+      return await decryptDataWithKey(value.slice(`enc:${version}:`.length), ring[version]);
+    } catch {
+      continue;
+    }
+  }
+  throw new MemoryKeyError(`No supplied key decrypts this enc:${version} field`);
+}
+function memoryCipher(canonical) {
+  return {
+    encrypt: async (plaintext) => `enc:v3:${await encryptDataWithKey(plaintext, canonical.v3)}`,
+    decrypt: async (ciphertext) => {
+      if (!ciphertext.startsWith("enc:v3:") || !isEncrypted(ciphertext))
+        throw new MemoryKeyError("Remote memory content must be enc:v3 ciphertext");
+      return decryptWith(ciphertext, [canonical]);
+    }
+  };
+}
+async function reencryptMemoryField(value, canonical, fallbacks = []) {
+  const { encrypt } = memoryCipher(canonical);
+  if (!value.startsWith("enc:")) return encrypt(value);
+  if (!isEncrypted(value))
+    throw new MemoryKeyError("Field has an encryption prefix but an invalid payload");
+  return encrypt(await decryptWith(value, [canonical, ...fallbacks]));
+}
+
 // src/lib/memory/store/remotePersistence.ts
 var RemoteMemoryError = class extends Error {
   constructor(message, status, code) {
@@ -21036,6 +21280,30 @@ var candidateListLimits = [
   ["memory_ids", 1e3],
   ["force_ids", 100]
 ];
+var queryListLimits = [
+  ["scopes", 20],
+  ["fact_types", 20],
+  ["visibility", 20],
+  ["memory_ids", 1e3],
+  ["topics", 100]
+];
+var queryFields = [
+  "include_deleted",
+  "include_archived",
+  "include_quarantined",
+  "include_superseded",
+  "archived_only",
+  "scopes",
+  "fact_types",
+  "visibility",
+  "memory_ids",
+  "topics",
+  "updated_after",
+  "order",
+  "cursor",
+  "limit",
+  "include_embeddings"
+];
 function record(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -21370,6 +21638,35 @@ async function createRemoteMemoryPersistence(options) {
         throw new Error("Invalid nearby batch response");
       return Promise.all(result.items.map((item, i) => decodeCommitted(item, prepared[i])));
     },
+    query: async (queryOptions = {}) => {
+      const { signal, ...query } = queryOptions;
+      if (query.limit !== void 0 && (!Number.isInteger(query.limit) || query.limit < 1 || query.limit > 200))
+        throw new Error("Page limit must be 1\u2013200");
+      for (const [key, max] of queryListLimits) {
+        const values = query[key];
+        if (values && values.length > max)
+          throw new Error(`Query ${key} accepts at most ${max} entries (got ${values.length})`);
+      }
+      const page = await request(
+        "/memories/query",
+        {
+          method: "POST",
+          body: JSON.stringify(
+            Object.fromEntries(
+              queryFields.filter((key) => query[key] !== void 0).map((key) => [key, query[key]])
+            )
+          )
+        },
+        signal
+      );
+      if (!record(page) || !Array.isArray(page.items) || page.next_cursor !== void 0 && typeof page.next_cursor !== "string" || page.changes_cursor !== void 0 && typeof page.changes_cursor !== "string")
+        throw new Error("Invalid nearby private-memory page");
+      return {
+        ...await decodeAll(page.items),
+        ...page.next_cursor !== void 0 && { next_cursor: page.next_cursor },
+        ...page.changes_cursor !== void 0 && { changes_cursor: page.changes_cursor }
+      };
+    },
     candidateSet,
     candidates: async (embedding, candidateOptions = {}) => decodeAll((await fetchCandidates(embedding, candidateOptions, false)).items)
   };
@@ -21394,6 +21691,9 @@ function sourceIds(value) {
     return [];
   }
 }
+function isMemoryLevel(value) {
+  return MEMORY_LEVELS.includes(value);
+}
 function stored(row) {
   return {
     uniqueId: row.memory_id,
@@ -21401,6 +21701,9 @@ function stored(row) {
     scope: row.scope,
     folderId: row.folder_id ?? null,
     userId: null,
+    kind: row.kind ?? null,
+    kindValue: row.kind_value ?? null,
+    ...isMemoryLevel(row.level) && { level: row.level },
     embedding: row.embedding ? JSON.stringify(row.embedding) : null,
     embeddingModel: row.embedding_model ?? null,
     sourceChunkIds: row.source_chunk_ids === void 0 ? null : sourceIds(row.source_chunk_ids),
@@ -21622,7 +21925,8 @@ function createRemoteMemoryPipeline(options) {
       create: (input) => write(createRow(input), 0),
       update: async (id, patch) => {
         const existing = await get(id);
-        if (!existing) return null;
+        if (!existing || patch.freeFormOnly && existing.kind !== null && existing.kind !== void 0)
+          return null;
         const snapshot = snapshots.get(id);
         const memory = {
           ...snapshot.memory,
@@ -21751,6 +22055,489 @@ function createRemoteMemoryPipeline(options) {
   };
 }
 
+// src/lib/memory/store/remoteStore.ts
+import { v7 as uuidv76 } from "uuid";
+function relevant(change, options) {
+  return options.includeDeleted ? change === "membership" : change !== "embedding" || !!options.embeddings;
+}
+function safely(onChange) {
+  try {
+    onChange();
+  } catch (error) {
+    getLogger().warn("[memory/remote-store] Subscriber threw:", error);
+  }
+}
+var MAX_BATCH = 50;
+var MAX_QUERY_IDS = 1e3;
+var MAX_QUERY_TOPICS = 100;
+var MAX_QUERY_FILTER = 20;
+var RemoteMemoryPartialCreateError = class extends Error {
+  constructor(created, cause) {
+    super(`createMany stored ${created.length} memories before a batch failed`);
+    this.created = created;
+    this.cause = cause;
+    this.name = "RemoteMemoryPartialCreateError";
+  }
+};
+function warnFailed(failed) {
+  if (failed.length)
+    getLogger().warn(
+      `[memory/remote-store] Skipping ${failed.length} undecryptable row(s)`,
+      failed.map((failure) => failure.memory_id)
+    );
+}
+function bounded(filters, key) {
+  const values = filters[key];
+  if (!values || values.length <= MAX_QUERY_FILTER) return [filters];
+  return chunks(values, MAX_QUERY_FILTER).map((chunk) => ({ ...filters, [key]: chunk }));
+}
+function chunks(values, size) {
+  const out = [];
+  for (let i = 0; i < values.length; i += size) out.push(values.slice(i, i + size));
+  return out;
+}
+function stateFilters(options) {
+  return {
+    include_deleted: options.includeDeleted,
+    include_archived: options.includeArchived,
+    include_quarantined: options.includeQuarantined,
+    include_superseded: options.includeSuperseded
+  };
+}
+function hidden(memory, options) {
+  if (memory.trust_tier === "quarantined") return true;
+  if (options.includeDeleted) return false;
+  return !!memory.is_deleted || memory.archived_at !== void 0 && memory.archived_at !== null || !!memory.superseded_by;
+}
+function subscriptionKey({ memory, version }, options) {
+  if (hidden(memory, options)) return void 0;
+  if (options.includeDeleted) return String(!!memory.is_deleted);
+  return JSON.stringify([
+    options.embeddings ? version : null,
+    memory.content,
+    memory.scope,
+    memory.updated_at,
+    memory.fact_type,
+    memory.event_time_start,
+    memory.event_time_end,
+    memory.event_time_kind,
+    memory.trust_tier,
+    memory.visibility,
+    memory.published_at,
+    memory.geohash,
+    memory.topics,
+    memory.topics_user_managed,
+    memory.media,
+    memory.source
+  ]);
+}
+function topicInputs(topics, source) {
+  return topics.flatMap((topic) => {
+    const name = (typeof topic === "string" ? topic : topic.name).trim();
+    const kind = typeof topic === "string" ? void 0 : topic.kind;
+    return name ? [{ name, ...kind && { kind }, source }] : [];
+  });
+}
+function mergeTopics(existing, added) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const topic of [...existing, ...added]) {
+    const key = normalizeEntityName(topic.name);
+    if (!byName.has(key)) byName.set(key, topic);
+  }
+  return [...byName.values()];
+}
+function canonicalTopics(row) {
+  return new Set((parseTopics(row.topics) ?? []).map((topic) => normalizeEntityName(topic.name)));
+}
+function createRemoteMemoryStore(options) {
+  const { persistence, embeddingOptions } = options;
+  const model = embeddingOptions.model ?? DEFAULT_API_EMBEDDING_MODEL;
+  const pollIntervalMs = options.pollIntervalMs ?? 6e4;
+  const pipeline = createRemoteMemoryPipeline(options);
+  const subscribers = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Map();
+  let timer;
+  const notify = (change, records = []) => {
+    if (timer) for (const record2 of records) seen.set(record2.memory.memory_id, record2);
+    for (const subscriber of [...subscribers])
+      if (relevant(change, subscriber.options)) safely(subscriber.onChange);
+  };
+  const enumerate = async (filters, max = Infinity) => {
+    const records = [];
+    let cursor2;
+    do {
+      const page = await persistence.query({
+        ...filters,
+        limit: Math.min(200, Math.max(1, max - records.length)),
+        ...cursor2 && { cursor: cursor2 }
+      });
+      warnFailed(page.failed);
+      records.push(...page.items);
+      cursor2 = page.next_cursor;
+    } while (cursor2 && records.length < max);
+    return records.slice(0, max);
+  };
+  const enumerateIds = async (ids, filters) => (await Promise.all(
+    chunks([...new Set(ids)], MAX_QUERY_IDS).map(
+      (memory_ids) => enumerate({ ...filters, memory_ids })
+    )
+  )).flat();
+  const queues = /* @__PURE__ */ new Map();
+  const serialized = (id, task) => {
+    const run = (queues.get(id) ?? Promise.resolve()).then(task, task);
+    const settled = run.catch(() => void 0);
+    queues.set(id, settled);
+    void settled.then(() => {
+      if (queues.get(id) === settled) queues.delete(id);
+    });
+    return run;
+  };
+  const live = async (id) => {
+    const record2 = await persistence.get(id);
+    return record2 && !record2.memory.is_deleted ? record2 : null;
+  };
+  const mutate = async (id, change, edit) => serialized(id, async () => {
+    const record2 = await live(id);
+    if (!record2) return null;
+    const next = edit(structuredClone(record2.memory));
+    if (!next) return null;
+    const saved = await persistence.put(next, record2);
+    notify(change, [saved]);
+    return saved;
+  });
+  const embedInBackground = ({ memory: { memory_id: id, content } }) => {
+    generateEmbedding(content, embeddingOptions).then(
+      (vector) => serialized(id, async () => {
+        const current = await live(id);
+        if (!current || current.memory.content !== content || current.memory.embedding?.length)
+          return;
+        const saved = await persistence.put(
+          { ...current.memory, embedding: storedVector(vector), embedding_model: model },
+          current
+        );
+        notify("embedding", [saved]);
+      })
+    ).catch((error) => {
+      getLogger().warn("[memory/remote-store] Failed to embed memory:", error);
+    });
+  };
+  const newRow = (input) => {
+    const now = Date.now();
+    const scope = input.scope ?? "private";
+    return {
+      memory_id: uuidv76(),
+      content: input.content,
+      scope,
+      level: levelFromScope(scope),
+      created_at: now,
+      updated_at: now,
+      is_deleted: false,
+      ...input.embedding !== void 0 && {
+        embedding: storedVector(JSON.parse(input.embedding)),
+        embedding_model: input.embeddingModel ?? model
+      },
+      proof_count: 1,
+      source: "manual",
+      ...input.eventTime && {
+        event_time_start: input.eventTime.start ?? void 0,
+        event_time_end: input.eventTime.end ?? void 0,
+        event_time_kind: input.eventTime.kind ?? void 0
+      },
+      fact_type: input.factType,
+      geohash: input.geohash,
+      visibility: "private",
+      twin_opt_in: false
+    };
+  };
+  const created = (records, inputs) => {
+    records.forEach((record2, i) => {
+      if (inputs[i].embedding === void 0) embedInBackground(record2);
+    });
+    notify("membership", records);
+    return records.map((record2) => stored(record2.memory));
+  };
+  const asStored = (record2) => record2 ? stored(record2.memory) : null;
+  const everyState = {
+    include_deleted: true,
+    include_archived: true,
+    include_quarantined: true,
+    include_superseded: true
+  };
+  const changesSince = async (cursor2, pending2) => {
+    const records = [];
+    const failed = /* @__PURE__ */ new Set();
+    const collect = (page) => {
+      warnFailed(page.failed);
+      records.push(...page.items);
+      for (const failure of page.failed) failed.add(failure.memory_id);
+    };
+    let resume = cursor2;
+    let next;
+    do {
+      const page = await persistence.query({
+        ...everyState,
+        order: "changed",
+        limit: 200,
+        ...(next ?? resume) && { cursor: next ?? resume }
+      });
+      collect(page);
+      resume = page.changes_cursor ?? resume;
+      next = page.next_cursor;
+    } while (next);
+    for (const memory_ids of chunks([...pending2], MAX_QUERY_IDS)) {
+      let retry;
+      do {
+        const page = await persistence.query({
+          ...everyState,
+          memory_ids,
+          limit: 200,
+          ...retry && { cursor: retry }
+        });
+        collect(page);
+        retry = page.next_cursor;
+      } while (retry);
+    }
+    return { records, resume, failed };
+  };
+  let generation = 0;
+  let ready = false;
+  let cursor;
+  let pending = /* @__PURE__ */ new Set();
+  let polling = false;
+  const poll = () => {
+    if (polling) return;
+    polling = true;
+    const current = generation;
+    changesSince(cursor, pending).then(({ records, resume, failed }) => {
+      if (current !== generation) return;
+      const changed = /* @__PURE__ */ new Set();
+      for (const record2 of records) {
+        const id = record2.memory.memory_id;
+        const previous = seen.get(id);
+        seen.set(id, record2);
+        if (!ready) continue;
+        for (const subscriber of subscribers) {
+          const before = previous && subscriptionKey(previous, subscriber.options);
+          if (before !== subscriptionKey(record2, subscriber.options)) changed.add(subscriber);
+        }
+      }
+      ready = true;
+      cursor = resume;
+      pending = failed;
+      for (const subscriber of changed)
+        if (subscribers.has(subscriber)) safely(subscriber.onChange);
+    }).catch((error) => {
+      getLogger().warn("[memory/remote-store] Subscription poll failed:", error);
+    }).finally(() => {
+      polling = false;
+    });
+  };
+  return {
+    list: async (listOptions = {}) => {
+      const order = listOptions.since ? "updated" : "created";
+      const filters = {
+        ...stateFilters(listOptions),
+        include_embeddings: true,
+        order,
+        ...listOptions.scopes?.length && { scopes: listOptions.scopes },
+        ...listOptions.factTypes?.length && { fact_types: listOptions.factTypes },
+        ...listOptions.visibility?.length && { visibility: listOptions.visibility },
+        ...listOptions.since && { updated_after: listOptions.since.getTime() }
+      };
+      const max = listOptions.limit && listOptions.limit > 0 ? listOptions.limit : Infinity;
+      const variants = bounded(filters, "scopes").flatMap((f) => bounded(f, "fact_types"));
+      if (!listOptions.memoryIds && variants.length === 1)
+        return (await enumerate(filters, max)).map((r) => stored(r.memory));
+      const fetched = await Promise.all(
+        variants.map(
+          (variant) => listOptions.memoryIds ? enumerateIds(listOptions.memoryIds, variant) : enumerate(variant, max)
+        )
+      );
+      const rows = [...new Map(fetched.flat().map((r) => [r.memory.memory_id, r])).values()].map((record2) => stored(record2.memory)).sort(
+        (a, b) => order === "updated" ? b.updatedAt.getTime() - a.updatedAt.getTime() || (a.uniqueId < b.uniqueId ? 1 : -1) : b.createdAt.getTime() - a.createdAt.getTime() || (a.uniqueId < b.uniqueId ? 1 : -1)
+      );
+      return rows.slice(0, max);
+    },
+    get: async (id) => asStored(await live(id)),
+    listArchived: async () => (await enumerate({ archived_only: true, order: "archived", include_embeddings: true })).map(
+      (record2) => stored(record2.memory)
+    ),
+    memoriesByTopics: async (names) => {
+      const wanted = new Set(names.map(normalizeEntityName).filter(Boolean));
+      const out = /* @__PURE__ */ new Map();
+      const pages = await Promise.all(
+        chunks([...wanted], MAX_QUERY_TOPICS).map((topics) => enumerate({ topics }))
+      );
+      for (const { memory } of pages.flat()) {
+        const matched = [...canonicalTopics(memory)].filter((name) => wanted.has(name));
+        if (matched.length) out.set(memory.memory_id, new Set(matched));
+      }
+      return out;
+    },
+    topicsByMemories: async (memoryIds) => {
+      const out = /* @__PURE__ */ new Map();
+      for (const { memory } of await enumerateIds(memoryIds, {
+        include_archived: true,
+        include_superseded: true,
+        include_quarantined: true
+      })) {
+        const topics = canonicalTopics(memory);
+        if (topics.size) out.set(memory.memory_id, topics);
+      }
+      return out;
+    },
+    create: async (input) => {
+      const record2 = await persistence.put(newRow(input), 0);
+      return created([record2], [input])[0];
+    },
+    createMany: async (inputs) => {
+      const out = [];
+      for (const batch of chunks(inputs, MAX_BATCH)) {
+        let records;
+        try {
+          records = await persistence.putMany(
+            batch.map((input) => ({ memory: newRow(input), expectedVersion: 0 }))
+          );
+        } catch (error) {
+          if (out.length === 0) throw error;
+          throw new RemoteMemoryPartialCreateError(out, error);
+        }
+        out.push(...created(records, batch));
+      }
+      return out;
+    },
+    update: async (id, patch) => {
+      const saved = await mutate(id, "edit", (memory) => {
+        if (memory.superseded_by) return null;
+        memory.content = patch.content;
+        memory.updated_at = Date.now();
+        if (patch.scope !== void 0) {
+          memory.level = levelForScopeChange(
+            { level: memory.level, scope: memory.scope },
+            patch.scope
+          );
+          memory.scope = patch.scope;
+        }
+        if (patch.factType !== void 0) memory.fact_type = patch.factType ?? void 0;
+        if (patch.eventTime !== void 0) {
+          memory.event_time_start = patch.eventTime?.start ?? void 0;
+          memory.event_time_end = patch.eventTime?.end ?? void 0;
+          memory.event_time_kind = patch.eventTime?.kind ?? void 0;
+        }
+        if (patch.embedding === void 0 || patch.embedding === null) {
+          memory.embedding = [];
+          delete memory.embedding_model;
+        } else {
+          memory.embedding = storedVector(JSON.parse(patch.embedding));
+          memory.embedding_model = patch.embeddingModel ?? model;
+        }
+        return memory;
+      });
+      if (saved && patch.embedding === void 0) embedInBackground(saved);
+      return asStored(saved);
+    },
+    delete: async (id) => !!await mutate(id, "membership", (memory) => ({ ...memory, is_deleted: true })),
+    supersede: async (id, supersededById) => {
+      if (id === supersededById) return false;
+      const [first, second] = [id, supersededById].sort();
+      return serialized(
+        first,
+        () => serialized(second, async () => {
+          const [old, next] = await Promise.all([live(id), live(supersededById)]);
+          if (!old || !next || old.memory.superseded_by || next.memory.superseded_by) return false;
+          if (old.memory.kind !== void 0 && old.memory.kind !== null) return false;
+          const saved = await persistence.putMany([
+            {
+              memory: { ...old.memory, superseded_by: supersededById, superseded_at: Date.now() },
+              expectedVersion: old
+            },
+            { memory: next.memory, expectedVersion: next }
+          ]);
+          notify("membership", saved);
+          return true;
+        })
+      );
+    },
+    archive: async (id) => !!await mutate(
+      id,
+      "edit",
+      (memory) => memory.archived_at === void 0 || memory.archived_at === null ? { ...memory, archived_at: Date.now() } : null
+    ),
+    restore: (id) => serialized(id, async () => {
+      const record2 = await live(id);
+      if (!record2) return false;
+      if (record2.memory.archived_at === void 0 || record2.memory.archived_at === null)
+        return true;
+      const { archived_at: _archivedAt, ...memory } = record2.memory;
+      notify("edit", [await persistence.put(memory, record2)]);
+      return true;
+    }),
+    setTopics: async (memoryId, topics) => asStored(
+      await mutate(memoryId, "edit", (memory) => ({
+        ...memory,
+        topics: serializeTopics(mergeTopics([], topicInputs(topics, "user"))),
+        topics_user_managed: true,
+        topics_updated_at: Date.now()
+      }))
+    ),
+    addTopics: async (memoryId, topics) => {
+      const added = topicInputs(topics, "auto");
+      const saved = await mutate(memoryId, "edit", (memory) => ({
+        ...memory,
+        topics: serializeTopics(mergeTopics(parseTopics(memory.topics) ?? [], added)),
+        topics_updated_at: Date.now()
+      }));
+      if (!saved) return [];
+      const now = /* @__PURE__ */ new Date();
+      return mergeTopics([], added).map(
+        (topic) => ({
+          uniqueId: normalizeEntityName(topic.name),
+          canonicalName: normalizeEntityName(topic.name),
+          kind: topic.kind ?? null,
+          createdAt: now,
+          updatedAt: now
+        })
+      );
+    },
+    setVisibility: async (id, visibility, visibilityOptions) => asStored(
+      await mutate(id, "edit", (memory) => {
+        memory.visibility = visibility;
+        if (visibility === "private") delete memory.published_at;
+        else memory.published_at ?? (memory.published_at = Date.now());
+        if (visibilityOptions?.twinOptIn !== void 0)
+          memory.twin_opt_in = visibilityOptions.twinOptIn;
+        return memory;
+      })
+    ),
+    recall: (query, recallOptions) => pipeline.recall(query, recallOptions),
+    retain: async (content, retainOptions) => {
+      const result = await pipeline.retain(content, retainOptions);
+      if (result.action === "create" || result.action === "supersede") notify("membership");
+      else if (result.action === "update" || result.action === "merge") notify("edit");
+      return result;
+    },
+    subscribe: (onChange, subscribeOptions = {}) => {
+      const subscriber = { onChange, options: subscribeOptions };
+      subscribers.add(subscriber);
+      if (pollIntervalMs > 0 && !timer) {
+        timer = setInterval(poll, pollIntervalMs);
+        poll();
+      }
+      return () => {
+        subscribers.delete(subscriber);
+        if (subscribers.size || !timer) return;
+        clearInterval(timer);
+        timer = void 0;
+        generation++;
+        seen.clear();
+        ready = false;
+        cursor = void 0;
+        pending = /* @__PURE__ */ new Set();
+      };
+    }
+  };
+}
+
 // src/lib/memory/synthesizeProfile.ts
 var DEFAULT_SYNTHESIS_MODEL = "inclusionai/ling-2.6-flash";
 var DEFAULT_FACET_RECALL_LIMIT = 20;
@@ -35729,7 +36516,11 @@ export {
   LoggerProvider,
   MAX_HOPS,
   MEDIUM_TTL_MS,
+  MEMORY_KINDS,
+  MEMORY_LEVELS,
   MemoryEntity as MemoryEntityModel,
+  MemoryKeyError,
+  MemoryLevelError,
   NEVER_TTL_MS,
   NODE_BUDGET,
   PAST_EVENT_GRACE_MS,
@@ -35743,6 +36534,7 @@ export {
   RECALL_MAX_LIMIT,
   RECALL_TOOL_NAME,
   RemoteMemoryError,
+  RemoteMemoryPartialCreateError,
   RerankerUnavailableError,
   SDK_SCHEMA_VERSION,
   SERVER_TOOL_DEPENDENCY_SETS,
@@ -35836,6 +36628,7 @@ export {
   createRecallTool,
   createRemoteMemoryPersistence,
   createRemoteMemoryPipeline,
+  createRemoteMemoryStore,
   createSavedToolOp,
   createServerToolsFilter,
   createStockPricePreProcessor,
@@ -35867,6 +36660,7 @@ export {
   deleteVaultMemoryOp,
   dequantizeEmbedding,
   deriveKeyFromSignatureBytes,
+  deriveMemoryKeyRing,
   eagerEmbedContent,
   embedAllMessages,
   embedMessage,
@@ -36006,6 +36800,7 @@ export {
   linkMemoryEntitiesOp,
   maskScopedEmbeddingCache,
   mediaToStored,
+  memoryCipher,
   migrateCalendarToken,
   migrateDisplayResult,
   migrateDriveToken,
@@ -36027,6 +36822,7 @@ export {
   rankProfileCandidates,
   readEncryptedFile,
   recall,
+  reencryptMemoryField,
   reflect,
   refreshCalendarToken,
   refreshDriveToken,