@anuma/sdk 9.1.2 → 9.1.4

package/dist/expo/index.cjs

@@ -2326,6 +2326,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -2338,6 +2339,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -22923,6 +22927,8 @@ async function backfillTopics(ctx) {
   if (topicless.length > 0) await backfillMemoryTopicsOp(ctx, topicless);
 }
 async function migrateMemoriesToRemote(options) {
+  if (typeof options.withWriteBarrier !== "function" || typeof options.onActivated !== "function")
+    throw new Error("A write barrier and a remote store handoff are required");
   const { canonical, signal } = options;
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
@@ -22950,93 +22956,98 @@ async function migrateMemoriesToRemote(options) {
   const placeholders = /* @__PURE__ */ new Set();
   const truncated = /* @__PURE__ */ new Set();
   let imported = 0;
-  for (let pass = 0; ; pass++) {
-    const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
-    for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
-    const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
-    const missing = await missingIds(request, candidates.map(revision), signal);
-    const pending = /* @__PURE__ */ new Map();
-    for (const raw of candidates)
-      if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
-    if (pending.size === 0 && !active) {
-      const remote = await remoteMetadata(
-        request,
-        candidates.map((raw) => raw.id),
-        signal
-      );
-      const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
-      for (const raw of candidates) {
-        const server = remote.get(raw.id);
-        if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
-          pending.set(raw.id, raw.updated_at + 1);
-      }
-    }
-    if (pending.size === 0) {
-      const result = (state) => ({
-        state,
-        total: rows.length,
-        imported,
-        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
-        reembedded: reembedded.size,
-        unembedded: unembedded.size,
-        placeholderTombstones: placeholders.size,
-        truncatedSourceChunkIds: truncated.size
-      });
-      if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
-      if (!claimed) await importBatch(request, canonical.keyId, [], signal);
-      if (!active)
-        await request(
-          "/account",
-          { method: "PUT", body: JSON.stringify({ state: "active" }) },
+  const uploadPasses = async (finalizing = false) => {
+    for (let pass = 0; ; pass++) {
+      const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
+      for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
+      const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
+      const missing = await missingIds(request, candidates.map(revision), signal);
+      const pending = /* @__PURE__ */ new Map();
+      for (const raw of candidates)
+        if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
+      if (pending.size === 0 && !active) {
+        const remote = await remoteMetadata(
+          request,
+          candidates.map((raw) => raw.id),
           signal
         );
-      return result("active");
-    }
-    if (pass >= MAX_UPLOAD_PASSES)
-      throw new RemoteMemoryError(
-        "Nearby still reports memories missing after importing them",
-        409,
-        "migration_incomplete"
-      );
-    const prepared = [];
-    for (const raw of candidates) {
-      const updatedAt = pending.get(raw.id);
-      if (updatedAt === void 0) continue;
-      try {
-        prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
-      } catch (error) {
-        if (!(error instanceof MemoryKeyError)) throw error;
-        skipped.set(raw.id, "unreadable");
-      }
-    }
-    const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
-    if (options.embeddingOptions)
-      await embedMissing(prepared, options.embeddingOptions, model, signal);
-    const local = new Map(candidates.map((raw) => [raw.id, raw]));
-    const upload = [];
-    for (const { row, plaintext } of prepared) {
-      const id2 = row.memory_id;
-      if (!fitsNearby(row)) {
-        skipped.set(id2, "invalid");
-        continue;
+        const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
+        for (const raw of candidates) {
+          const server = remote.get(raw.id);
+          if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
+            pending.set(raw.id, raw.updated_at + 1);
+        }
+      }
+      if (pending.size === 0) {
+        const result = (state) => ({
+          state,
+          total: rows.length,
+          imported,
+          skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
+          reembedded: reembedded.size,
+          unembedded: unembedded.size,
+          placeholderTombstones: placeholders.size,
+          truncatedSourceChunkIds: truncated.size
+        });
+        if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
+        if (!finalizing) return options.withWriteBarrier(() => uploadPasses(true));
+        if (!claimed) await importBatch(request, canonical.keyId, [], signal);
+        if (!active)
+          await request(
+            "/account",
+            { method: "PUT", body: JSON.stringify({ state: "active" }) },
+            signal
+          );
+        await options.onActivated();
+        return result("active");
+      }
+      if (pass >= MAX_UPLOAD_PASSES)
+        throw new RemoteMemoryError(
+          "Nearby still reports memories missing after importing them",
+          409,
+          "migration_incomplete"
+        );
+      const prepared = [];
+      for (const raw of candidates) {
+        const updatedAt = pending.get(raw.id);
+        if (updatedAt === void 0) continue;
+        try {
+          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+        } catch (error) {
+          if (!(error instanceof MemoryKeyError)) throw error;
+          skipped.set(raw.id, "unreadable");
+        }
+      }
+      const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
+      if (options.embeddingOptions)
+        await embedMissing(prepared, options.embeddingOptions, model, signal);
+      const local = new Map(candidates.map((raw) => [raw.id, raw]));
+      const upload = [];
+      for (const { row, plaintext } of prepared) {
+        const id2 = row.memory_id;
+        if (!fitsNearby(row)) {
+          skipped.set(id2, "invalid");
+          continue;
+        }
+        upload.push(row);
+        const track = (set, on) => on ? set.add(id2) : set.delete(id2);
+        track(reembedded, !!row.embedding && !usable.has(id2));
+        track(unembedded, !row.embedding);
+        track(placeholders, plaintext === void 0);
+        track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
       }
-      upload.push(row);
-      const track = (set, on) => on ? set.add(id2) : set.delete(id2);
-      track(reembedded, !!row.embedding && !usable.has(id2));
-      track(unembedded, !row.embedding);
-      track(placeholders, plaintext === void 0);
-      track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
-    }
-    let sent = 0;
-    options.onProgress?.({ imported: sent, toImport: upload.length });
-    for (const batch of chunks(upload, IMPORT_BATCH)) {
-      await importBatch(request, canonical.keyId, batch, signal);
-      claimed = true;
-      sent += batch.length;
+      let sent = 0;
       options.onProgress?.({ imported: sent, toImport: upload.length });
+      for (const batch of chunks(upload, IMPORT_BATCH)) {
+        await importBatch(request, canonical.keyId, batch, signal);
+        claimed = true;
+        sent += batch.length;
+        options.onProgress?.({ imported: sent, toImport: upload.length });
+      }
+      imported += sent;
     }
-    imported += sent;
-  }
+  };
+  return uploadPasses();
 }
 
 // src/lib/memory/store/remoteStore.ts
@@ -25015,6 +25026,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 var import_watermelondb25 = require("@nozbe/watermelondb");
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      import_watermelondb25.Q.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -25583,9 +25606,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -25595,7 +25618,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/dist/expo/index.d.mts

@@ -9931,6 +9931,10 @@ interface MemoryMigrationOptions extends Pick<RemoteMemoryPersistenceOptions, "b
         name: string;
         kind?: string;
     }[];
+    /** Drain all local memory writes, block new writes until the task returns, and retain the block if the remote handoff fails. */
+    withWriteBarrier: (task: () => Promise<MemoryMigrationResult>) => Promise<MemoryMigrationResult>;
+    /** Route all subsequent memory writes to the remote store before this callback returns. */
+    onActivated: () => void | Promise<void>;
     signal?: AbortSignal;
     onProgress?: (progress: MemoryMigrationProgress) => void;
 }

package/dist/expo/index.d.ts

@@ -9931,6 +9931,10 @@ interface MemoryMigrationOptions extends Pick<RemoteMemoryPersistenceOptions, "b
         name: string;
         kind?: string;
     }[];
+    /** Drain all local memory writes, block new writes until the task returns, and retain the block if the remote handoff fails. */
+    withWriteBarrier: (task: () => Promise<MemoryMigrationResult>) => Promise<MemoryMigrationResult>;
+    /** Route all subsequent memory writes to the remote store before this callback returns. */
+    onActivated: () => void | Promise<void>;
     signal?: AbortSignal;
     onProgress?: (progress: MemoryMigrationProgress) => void;
 }

package/dist/expo/index.mjs

@@ -729,6 +729,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -741,6 +742,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -21248,6 +21252,8 @@ async function backfillTopics(ctx) {
   if (topicless.length > 0) await backfillMemoryTopicsOp(ctx, topicless);
 }
 async function migrateMemoriesToRemote(options) {
+  if (typeof options.withWriteBarrier !== "function" || typeof options.onActivated !== "function")
+    throw new Error("A write barrier and a remote store handoff are required");
   const { canonical, signal } = options;
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
@@ -21275,93 +21281,98 @@ async function migrateMemoriesToRemote(options) {
   const placeholders = /* @__PURE__ */ new Set();
   const truncated = /* @__PURE__ */ new Set();
   let imported = 0;
-  for (let pass = 0; ; pass++) {
-    const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
-    for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
-    const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
-    const missing = await missingIds(request, candidates.map(revision), signal);
-    const pending = /* @__PURE__ */ new Map();
-    for (const raw of candidates)
-      if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
-    if (pending.size === 0 && !active) {
-      const remote = await remoteMetadata(
-        request,
-        candidates.map((raw) => raw.id),
-        signal
-      );
-      const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
-      for (const raw of candidates) {
-        const server = remote.get(raw.id);
-        if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
-          pending.set(raw.id, raw.updated_at + 1);
-      }
-    }
-    if (pending.size === 0) {
-      const result = (state) => ({
-        state,
-        total: rows.length,
-        imported,
-        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
-        reembedded: reembedded.size,
-        unembedded: unembedded.size,
-        placeholderTombstones: placeholders.size,
-        truncatedSourceChunkIds: truncated.size
-      });
-      if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
-      if (!claimed) await importBatch(request, canonical.keyId, [], signal);
-      if (!active)
-        await request(
-          "/account",
-          { method: "PUT", body: JSON.stringify({ state: "active" }) },
+  const uploadPasses = async (finalizing = false) => {
+    for (let pass = 0; ; pass++) {
+      const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
+      for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
+      const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
+      const missing = await missingIds(request, candidates.map(revision), signal);
+      const pending = /* @__PURE__ */ new Map();
+      for (const raw of candidates)
+        if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
+      if (pending.size === 0 && !active) {
+        const remote = await remoteMetadata(
+          request,
+          candidates.map((raw) => raw.id),
           signal
         );
-      return result("active");
-    }
-    if (pass >= MAX_UPLOAD_PASSES)
-      throw new RemoteMemoryError(
-        "Nearby still reports memories missing after importing them",
-        409,
-        "migration_incomplete"
-      );
-    const prepared = [];
-    for (const raw of candidates) {
-      const updatedAt = pending.get(raw.id);
-      if (updatedAt === void 0) continue;
-      try {
-        prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
-      } catch (error) {
-        if (!(error instanceof MemoryKeyError)) throw error;
-        skipped.set(raw.id, "unreadable");
-      }
-    }
-    const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
-    if (options.embeddingOptions)
-      await embedMissing(prepared, options.embeddingOptions, model, signal);
-    const local = new Map(candidates.map((raw) => [raw.id, raw]));
-    const upload = [];
-    for (const { row, plaintext } of prepared) {
-      const id2 = row.memory_id;
-      if (!fitsNearby(row)) {
-        skipped.set(id2, "invalid");
-        continue;
+        const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
+        for (const raw of candidates) {
+          const server = remote.get(raw.id);
+          if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
+            pending.set(raw.id, raw.updated_at + 1);
+        }
+      }
+      if (pending.size === 0) {
+        const result = (state) => ({
+          state,
+          total: rows.length,
+          imported,
+          skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
+          reembedded: reembedded.size,
+          unembedded: unembedded.size,
+          placeholderTombstones: placeholders.size,
+          truncatedSourceChunkIds: truncated.size
+        });
+        if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
+        if (!finalizing) return options.withWriteBarrier(() => uploadPasses(true));
+        if (!claimed) await importBatch(request, canonical.keyId, [], signal);
+        if (!active)
+          await request(
+            "/account",
+            { method: "PUT", body: JSON.stringify({ state: "active" }) },
+            signal
+          );
+        await options.onActivated();
+        return result("active");
+      }
+      if (pass >= MAX_UPLOAD_PASSES)
+        throw new RemoteMemoryError(
+          "Nearby still reports memories missing after importing them",
+          409,
+          "migration_incomplete"
+        );
+      const prepared = [];
+      for (const raw of candidates) {
+        const updatedAt = pending.get(raw.id);
+        if (updatedAt === void 0) continue;
+        try {
+          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+        } catch (error) {
+          if (!(error instanceof MemoryKeyError)) throw error;
+          skipped.set(raw.id, "unreadable");
+        }
       }
-      upload.push(row);
-      const track = (set, on) => on ? set.add(id2) : set.delete(id2);
-      track(reembedded, !!row.embedding && !usable.has(id2));
-      track(unembedded, !row.embedding);
-      track(placeholders, plaintext === void 0);
-      track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
-    }
-    let sent = 0;
-    options.onProgress?.({ imported: sent, toImport: upload.length });
-    for (const batch of chunks(upload, IMPORT_BATCH)) {
-      await importBatch(request, canonical.keyId, batch, signal);
-      claimed = true;
-      sent += batch.length;
+      const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
+      if (options.embeddingOptions)
+        await embedMissing(prepared, options.embeddingOptions, model, signal);
+      const local = new Map(candidates.map((raw) => [raw.id, raw]));
+      const upload = [];
+      for (const { row, plaintext } of prepared) {
+        const id2 = row.memory_id;
+        if (!fitsNearby(row)) {
+          skipped.set(id2, "invalid");
+          continue;
+        }
+        upload.push(row);
+        const track = (set, on) => on ? set.add(id2) : set.delete(id2);
+        track(reembedded, !!row.embedding && !usable.has(id2));
+        track(unembedded, !row.embedding);
+        track(placeholders, plaintext === void 0);
+        track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
+      }
+      let sent = 0;
       options.onProgress?.({ imported: sent, toImport: upload.length });
+      for (const batch of chunks(upload, IMPORT_BATCH)) {
+        await importBatch(request, canonical.keyId, batch, signal);
+        claimed = true;
+        sent += batch.length;
+        options.onProgress?.({ imported: sent, toImport: upload.length });
+      }
+      imported += sent;
     }
-    imported += sent;
-  }
+  };
+  return uploadPasses();
 }
 
 // src/lib/memory/store/remoteStore.ts
@@ -23337,6 +23348,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 import { Q as Q10 } from "@nozbe/watermelondb";
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      Q10.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(Q10.where("id", Q10.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -23905,9 +23928,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(Q10.where("id", Q10.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -23917,7 +23940,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/dist/index.cjs

@@ -1404,6 +1404,7 @@ var EncryptionKeyMissingError = class extends Error {
   }
 };
 var encryptionKeyStore = /* @__PURE__ */ new Map();
+var sessionEpoch = 0;
 var cryptoKeyCache = /* @__PURE__ */ new Map();
 var clearAllEncryptionStateCallbacks = /* @__PURE__ */ new Set();
 function onClearAllEncryptionState(callback) {
@@ -1455,6 +1456,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -1467,6 +1469,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -2159,7 +2164,7 @@ async function createRemoteChatStore(options) {
 var LRU_CAPACITY = 256;
 var titleCache = /* @__PURE__ */ new Map();
 var pendingDecrypts = /* @__PURE__ */ new Map();
-var sessionEpoch = 0;
+var sessionEpoch2 = 0;
 function buildCacheKey(address, encryptedTitle) {
   return `${address}:${encryptedTitle}`;
 }
@@ -2178,7 +2183,7 @@ function insertWithEviction(key, value) {
 function clearLazyTitleCache() {
   titleCache.clear();
   pendingDecrypts.clear();
-  sessionEpoch += 1;
+  sessionEpoch2 += 1;
 }
 onClearAllEncryptionState(clearLazyTitleCache);
 async function decryptConversationTitle(encryptedTitle, address) {
@@ -2200,13 +2205,13 @@ async function decryptConversationTitle(encryptedTitle, address) {
   }
   const inFlight = pendingDecrypts.get(cacheKey);
   if (inFlight) return inFlight;
-  const epochAtStart = sessionEpoch;
+  const epochAtStart = sessionEpoch2;
   const promise = (async () => {
     const plaintext = await decryptField(encryptedTitle, address);
     if (isEncrypted(plaintext)) {
       throw new Error("decryptConversationTitle: decryption failed (returned ciphertext)");
     }
-    if (sessionEpoch === epochAtStart) {
+    if (sessionEpoch2 === epochAtStart) {
       insertWithEviction(cacheKey, plaintext);
     }
     return plaintext;

package/dist/index.mjs

@@ -1201,6 +1201,7 @@ var EncryptionKeyMissingError = class extends Error {
   }
 };
 var encryptionKeyStore = /* @__PURE__ */ new Map();
+var sessionEpoch = 0;
 var cryptoKeyCache = /* @__PURE__ */ new Map();
 var clearAllEncryptionStateCallbacks = /* @__PURE__ */ new Set();
 function onClearAllEncryptionState(callback) {
@@ -1252,6 +1253,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -1264,6 +1266,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -1956,7 +1961,7 @@ async function createRemoteChatStore(options) {
 var LRU_CAPACITY = 256;
 var titleCache = /* @__PURE__ */ new Map();
 var pendingDecrypts = /* @__PURE__ */ new Map();
-var sessionEpoch = 0;
+var sessionEpoch2 = 0;
 function buildCacheKey(address, encryptedTitle) {
   return `${address}:${encryptedTitle}`;
 }
@@ -1975,7 +1980,7 @@ function insertWithEviction(key, value) {
 function clearLazyTitleCache() {
   titleCache.clear();
   pendingDecrypts.clear();
-  sessionEpoch += 1;
+  sessionEpoch2 += 1;
 }
 onClearAllEncryptionState(clearLazyTitleCache);
 async function decryptConversationTitle(encryptedTitle, address) {
@@ -1997,13 +2002,13 @@ async function decryptConversationTitle(encryptedTitle, address) {
   }
   const inFlight = pendingDecrypts.get(cacheKey);
   if (inFlight) return inFlight;
-  const epochAtStart = sessionEpoch;
+  const epochAtStart = sessionEpoch2;
   const promise = (async () => {
     const plaintext = await decryptField(encryptedTitle, address);
     if (isEncrypted(plaintext)) {
       throw new Error("decryptConversationTitle: decryption failed (returned ciphertext)");
     }
-    if (sessionEpoch === epochAtStart) {
+    if (sessionEpoch2 === epochAtStart) {
       insertWithEviction(cacheKey, plaintext);
     }
     return plaintext;

package/dist/react/index.cjs

@@ -2093,6 +2093,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -2105,6 +2106,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -25236,6 +25240,8 @@ async function backfillTopics(ctx) {
   if (topicless.length > 0) await backfillMemoryTopicsOp(ctx, topicless);
 }
 async function migrateMemoriesToRemote(options) {
+  if (typeof options.withWriteBarrier !== "function" || typeof options.onActivated !== "function")
+    throw new Error("A write barrier and a remote store handoff are required");
   const { canonical, signal } = options;
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
@@ -25263,93 +25269,98 @@ async function migrateMemoriesToRemote(options) {
   const placeholders = /* @__PURE__ */ new Set();
   const truncated = /* @__PURE__ */ new Set();
   let imported = 0;
-  for (let pass = 0; ; pass++) {
-    const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
-    for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
-    const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
-    const missing = await missingIds(request, candidates.map(revision), signal);
-    const pending = /* @__PURE__ */ new Map();
-    for (const raw of candidates)
-      if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
-    if (pending.size === 0 && !active) {
-      const remote = await remoteMetadata(
-        request,
-        candidates.map((raw) => raw.id),
-        signal
-      );
-      const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
-      for (const raw of candidates) {
-        const server = remote.get(raw.id);
-        if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
-          pending.set(raw.id, raw.updated_at + 1);
-      }
-    }
-    if (pending.size === 0) {
-      const result = (state) => ({
-        state,
-        total: rows.length,
-        imported,
-        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
-        reembedded: reembedded.size,
-        unembedded: unembedded.size,
-        placeholderTombstones: placeholders.size,
-        truncatedSourceChunkIds: truncated.size
-      });
-      if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
-      if (!claimed) await importBatch(request, canonical.keyId, [], signal);
-      if (!active)
-        await request(
-          "/account",
-          { method: "PUT", body: JSON.stringify({ state: "active" }) },
+  const uploadPasses = async (finalizing = false) => {
+    for (let pass = 0; ; pass++) {
+      const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
+      for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
+      const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
+      const missing = await missingIds(request, candidates.map(revision), signal);
+      const pending = /* @__PURE__ */ new Map();
+      for (const raw of candidates)
+        if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
+      if (pending.size === 0 && !active) {
+        const remote = await remoteMetadata(
+          request,
+          candidates.map((raw) => raw.id),
           signal
         );
-      return result("active");
-    }
-    if (pass >= MAX_UPLOAD_PASSES)
-      throw new RemoteMemoryError(
-        "Nearby still reports memories missing after importing them",
-        409,
-        "migration_incomplete"
-      );
-    const prepared = [];
-    for (const raw of candidates) {
-      const updatedAt = pending.get(raw.id);
-      if (updatedAt === void 0) continue;
-      try {
-        prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
-      } catch (error) {
-        if (!(error instanceof MemoryKeyError)) throw error;
-        skipped.set(raw.id, "unreadable");
-      }
-    }
-    const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
-    if (options.embeddingOptions)
-      await embedMissing(prepared, options.embeddingOptions, model, signal);
-    const local = new Map(candidates.map((raw) => [raw.id, raw]));
-    const upload = [];
-    for (const { row, plaintext } of prepared) {
-      const id2 = row.memory_id;
-      if (!fitsNearby(row)) {
-        skipped.set(id2, "invalid");
-        continue;
+        const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
+        for (const raw of candidates) {
+          const server = remote.get(raw.id);
+          if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
+            pending.set(raw.id, raw.updated_at + 1);
+        }
+      }
+      if (pending.size === 0) {
+        const result = (state) => ({
+          state,
+          total: rows.length,
+          imported,
+          skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
+          reembedded: reembedded.size,
+          unembedded: unembedded.size,
+          placeholderTombstones: placeholders.size,
+          truncatedSourceChunkIds: truncated.size
+        });
+        if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
+        if (!finalizing) return options.withWriteBarrier(() => uploadPasses(true));
+        if (!claimed) await importBatch(request, canonical.keyId, [], signal);
+        if (!active)
+          await request(
+            "/account",
+            { method: "PUT", body: JSON.stringify({ state: "active" }) },
+            signal
+          );
+        await options.onActivated();
+        return result("active");
+      }
+      if (pass >= MAX_UPLOAD_PASSES)
+        throw new RemoteMemoryError(
+          "Nearby still reports memories missing after importing them",
+          409,
+          "migration_incomplete"
+        );
+      const prepared = [];
+      for (const raw of candidates) {
+        const updatedAt = pending.get(raw.id);
+        if (updatedAt === void 0) continue;
+        try {
+          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+        } catch (error) {
+          if (!(error instanceof MemoryKeyError)) throw error;
+          skipped.set(raw.id, "unreadable");
+        }
+      }
+      const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
+      if (options.embeddingOptions)
+        await embedMissing(prepared, options.embeddingOptions, model, signal);
+      const local = new Map(candidates.map((raw) => [raw.id, raw]));
+      const upload = [];
+      for (const { row, plaintext } of prepared) {
+        const id2 = row.memory_id;
+        if (!fitsNearby(row)) {
+          skipped.set(id2, "invalid");
+          continue;
+        }
+        upload.push(row);
+        const track = (set, on) => on ? set.add(id2) : set.delete(id2);
+        track(reembedded, !!row.embedding && !usable.has(id2));
+        track(unembedded, !row.embedding);
+        track(placeholders, plaintext === void 0);
+        track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
       }
-      upload.push(row);
-      const track = (set, on) => on ? set.add(id2) : set.delete(id2);
-      track(reembedded, !!row.embedding && !usable.has(id2));
-      track(unembedded, !row.embedding);
-      track(placeholders, plaintext === void 0);
-      track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
-    }
-    let sent = 0;
-    options.onProgress?.({ imported: sent, toImport: upload.length });
-    for (const batch of chunks(upload, IMPORT_BATCH)) {
-      await importBatch(request, canonical.keyId, batch, signal);
-      claimed = true;
-      sent += batch.length;
+      let sent = 0;
       options.onProgress?.({ imported: sent, toImport: upload.length });
+      for (const batch of chunks(upload, IMPORT_BATCH)) {
+        await importBatch(request, canonical.keyId, batch, signal);
+        claimed = true;
+        sent += batch.length;
+        options.onProgress?.({ imported: sent, toImport: upload.length });
+      }
+      imported += sent;
     }
-    imported += sent;
-  }
+  };
+  return uploadPasses();
 }
 
 // src/lib/memory/store/remoteStore.ts
@@ -27328,6 +27339,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 var import_watermelondb34 = require("@nozbe/watermelondb");
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      import_watermelondb34.Q.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(import_watermelondb34.Q.where("id", import_watermelondb34.Q.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -27896,9 +27919,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(import_watermelondb34.Q.where("id", import_watermelondb34.Q.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -27908,7 +27931,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/dist/react/index.d.mts

@@ -11665,6 +11665,10 @@ interface MemoryMigrationOptions extends Pick<RemoteMemoryPersistenceOptions, "b
         name: string;
         kind?: string;
     }[];
+    /** Drain all local memory writes, block new writes until the task returns, and retain the block if the remote handoff fails. */
+    withWriteBarrier: (task: () => Promise<MemoryMigrationResult>) => Promise<MemoryMigrationResult>;
+    /** Route all subsequent memory writes to the remote store before this callback returns. */
+    onActivated: () => void | Promise<void>;
     signal?: AbortSignal;
     onProgress?: (progress: MemoryMigrationProgress) => void;
 }

package/dist/react/index.d.ts

@@ -11665,6 +11665,10 @@ interface MemoryMigrationOptions extends Pick<RemoteMemoryPersistenceOptions, "b
         name: string;
         kind?: string;
     }[];
+    /** Drain all local memory writes, block new writes until the task returns, and retain the block if the remote handoff fails. */
+    withWriteBarrier: (task: () => Promise<MemoryMigrationResult>) => Promise<MemoryMigrationResult>;
+    /** Route all subsequent memory writes to the remote store before this callback returns. */
+    onActivated: () => void | Promise<void>;
     signal?: AbortSignal;
     onProgress?: (progress: MemoryMigrationProgress) => void;
 }

package/dist/react/index.mjs

@@ -295,6 +295,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -307,6 +308,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -23353,6 +23357,8 @@ async function backfillTopics(ctx) {
   if (topicless.length > 0) await backfillMemoryTopicsOp(ctx, topicless);
 }
 async function migrateMemoriesToRemote(options) {
+  if (typeof options.withWriteBarrier !== "function" || typeof options.onActivated !== "function")
+    throw new Error("A write barrier and a remote store handoff are required");
   const { canonical, signal } = options;
   const rings = [canonical, ...options.fallbacks ?? []];
   const model = options.embeddingOptions?.model ?? DEFAULT_API_EMBEDDING_MODEL;
@@ -23380,93 +23386,98 @@ async function migrateMemoriesToRemote(options) {
   const placeholders = /* @__PURE__ */ new Set();
   const truncated = /* @__PURE__ */ new Set();
   let imported = 0;
-  for (let pass = 0; ; pass++) {
-    const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
-    for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
-    const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
-    const missing = await missingIds(request, candidates.map(revision), signal);
-    const pending = /* @__PURE__ */ new Map();
-    for (const raw of candidates)
-      if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
-    if (pending.size === 0 && !active) {
-      const remote = await remoteMetadata(
-        request,
-        candidates.map((raw) => raw.id),
-        signal
-      );
-      const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
-      for (const raw of candidates) {
-        const server = remote.get(raw.id);
-        if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
-          pending.set(raw.id, raw.updated_at + 1);
-      }
-    }
-    if (pending.size === 0) {
-      const result = (state) => ({
-        state,
-        total: rows.length,
-        imported,
-        skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
-        reembedded: reembedded.size,
-        unembedded: unembedded.size,
-        placeholderTombstones: placeholders.size,
-        truncatedSourceChunkIds: truncated.size
-      });
-      if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
-      if (!claimed) await importBatch(request, canonical.keyId, [], signal);
-      if (!active)
-        await request(
-          "/account",
-          { method: "PUT", body: JSON.stringify({ state: "active" }) },
+  const uploadPasses = async (finalizing = false) => {
+    for (let pass = 0; ; pass++) {
+      const rows = await getAllVaultMemoryRowsOp(options.vaultCtx);
+      for (const raw of rows) if (invalid2(raw)) skipped.set(String(raw.id), "invalid");
+      const candidates = rows.filter((raw) => !skipped.has(String(raw.id)));
+      const missing = await missingIds(request, candidates.map(revision), signal);
+      const pending = /* @__PURE__ */ new Map();
+      for (const raw of candidates)
+        if (missing.has(raw.id)) pending.set(raw.id, raw.updated_at);
+      if (pending.size === 0 && !active) {
+        const remote = await remoteMetadata(
+          request,
+          candidates.map((raw) => raw.id),
           signal
         );
-      return result("active");
-    }
-    if (pass >= MAX_UPLOAD_PASSES)
-      throw new RemoteMemoryError(
-        "Nearby still reports memories missing after importing them",
-        409,
-        "migration_incomplete"
-      );
-    const prepared = [];
-    for (const raw of candidates) {
-      const updatedAt = pending.get(raw.id);
-      if (updatedAt === void 0) continue;
-      try {
-        prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
-      } catch (error) {
-        if (!(error instanceof MemoryKeyError)) throw error;
-        skipped.set(raw.id, "unreadable");
-      }
-    }
-    const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
-    if (options.embeddingOptions)
-      await embedMissing(prepared, options.embeddingOptions, model, signal);
-    const local = new Map(candidates.map((raw) => [raw.id, raw]));
-    const upload = [];
-    for (const { row, plaintext } of prepared) {
-      const id2 = row.memory_id;
-      if (!fitsNearby(row)) {
-        skipped.set(id2, "invalid");
-        continue;
+        const needsVector = (raw, server) => !!options.embeddingOptions && !embedding(raw, model) && server.embedding_model !== model;
+        for (const raw of candidates) {
+          const server = remote.get(raw.id);
+          if (server && server.updated_at === raw.updated_at && (!sameMetadata2(raw, server, model) || needsVector(raw, server)))
+            pending.set(raw.id, raw.updated_at + 1);
+        }
+      }
+      if (pending.size === 0) {
+        const result = (state) => ({
+          state,
+          total: rows.length,
+          imported,
+          skipped: [...skipped].map(([memoryId, reason]) => ({ memoryId, reason })),
+          reembedded: reembedded.size,
+          unembedded: unembedded.size,
+          placeholderTombstones: placeholders.size,
+          truncatedSourceChunkIds: truncated.size
+        });
+        if (skipped.size > 0 && !options.allowSkipped) return result("migrating");
+        if (!finalizing) return options.withWriteBarrier(() => uploadPasses(true));
+        if (!claimed) await importBatch(request, canonical.keyId, [], signal);
+        if (!active)
+          await request(
+            "/account",
+            { method: "PUT", body: JSON.stringify({ state: "active" }) },
+            signal
+          );
+        await options.onActivated();
+        return result("active");
+      }
+      if (pass >= MAX_UPLOAD_PASSES)
+        throw new RemoteMemoryError(
+          "Nearby still reports memories missing after importing them",
+          409,
+          "migration_incomplete"
+        );
+      const prepared = [];
+      for (const raw of candidates) {
+        const updatedAt = pending.get(raw.id);
+        if (updatedAt === void 0) continue;
+        try {
+          prepared.push(await prepareRow(raw, canonical, rings, model, updatedAt));
+        } catch (error) {
+          if (!(error instanceof MemoryKeyError)) throw error;
+          skipped.set(raw.id, "unreadable");
+        }
+      }
+      const usable = new Set(prepared.filter((p) => p.row.embedding).map((p) => p.row.memory_id));
+      if (options.embeddingOptions)
+        await embedMissing(prepared, options.embeddingOptions, model, signal);
+      const local = new Map(candidates.map((raw) => [raw.id, raw]));
+      const upload = [];
+      for (const { row, plaintext } of prepared) {
+        const id2 = row.memory_id;
+        if (!fitsNearby(row)) {
+          skipped.set(id2, "invalid");
+          continue;
+        }
+        upload.push(row);
+        const track = (set, on) => on ? set.add(id2) : set.delete(id2);
+        track(reembedded, !!row.embedding && !usable.has(id2));
+        track(unembedded, !row.embedding);
+        track(placeholders, plaintext === void 0);
+        track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
       }
-      upload.push(row);
-      const track = (set, on) => on ? set.add(id2) : set.delete(id2);
-      track(reembedded, !!row.embedding && !usable.has(id2));
-      track(unembedded, !row.embedding);
-      track(placeholders, plaintext === void 0);
-      track(truncated, row.source_chunk_ids !== text13(local.get(id2).source_chunk_ids));
-    }
-    let sent = 0;
-    options.onProgress?.({ imported: sent, toImport: upload.length });
-    for (const batch of chunks(upload, IMPORT_BATCH)) {
-      await importBatch(request, canonical.keyId, batch, signal);
-      claimed = true;
-      sent += batch.length;
+      let sent = 0;
       options.onProgress?.({ imported: sent, toImport: upload.length });
+      for (const batch of chunks(upload, IMPORT_BATCH)) {
+        await importBatch(request, canonical.keyId, batch, signal);
+        claimed = true;
+        sent += batch.length;
+        options.onProgress?.({ imported: sent, toImport: upload.length });
+      }
+      imported += sent;
     }
-    imported += sent;
-  }
+  };
+  return uploadPasses();
 }
 
 // src/lib/memory/store/remoteStore.ts
@@ -25442,6 +25453,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 import { Q as Q17 } from "@nozbe/watermelondb";
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      Q17.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(Q17.where("id", Q17.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -26010,9 +26033,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(Q17.where("id", Q17.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -26022,7 +26045,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/dist/server/index.cjs

@@ -17078,6 +17078,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -17090,6 +17091,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -37141,6 +37145,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 var import_watermelondb25 = __toESM(require_watermelondb());
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      import_watermelondb25.Q.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -37709,9 +37725,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -37721,7 +37737,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/dist/server/index.mjs

@@ -15407,6 +15407,7 @@ async function getEncryptionKey(address, version = "v3") {
   if (cachedKey) {
     return cachedKey;
   }
+  const startEpoch = sessionEpoch;
   const keyHex = getStoredKeyByVersion(address, version);
   if (!keyHex) {
     throw new EncryptionKeyMissingError(address, version);
@@ -15419,6 +15420,9 @@ async function getEncryptionKey(address, version = "v3") {
     false,
     ["encrypt", "decrypt"]
   );
+  if (sessionEpoch !== startEpoch || getStoredKeyByVersion(address, version) !== keyHex) {
+    throw new EncryptionKeyMissingError(address, version);
+  }
   cryptoKeyCache.set(cacheKey, cryptoKey);
   return cryptoKey;
 }
@@ -35388,6 +35392,18 @@ async function assembleMemoryContext(options) {
 
 // src/lib/memory/durableExtraction.ts
 var import_watermelondb25 = __toESM(require_watermelondb());
+async function messagePositions(storage, ids) {
+  try {
+    return await storage.messagesCollection.query(
+      import_watermelondb25.Q.unsafeSqlQuery(
+        `select "id", "conversation_id", "message_id" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+        ids
+      )
+    ).unsafeFetchRaw();
+  } catch {
+    return await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).unsafeFetchRaw();
+  }
+}
 var MAX_JOBS_PER_PASS = 3;
 var MAX_ATTEMPTS = 3;
 var MAX_FAILED_SESSIONS = 3;
@@ -35956,9 +35972,9 @@ function createDurableAutoExtractor(options) {
                   r._setRaw("watermark_seq", null);
                 });
           }
-          const rows = fromSourceConversation ? [] : await storage.messagesCollection.query(import_watermelondb25.Q.where("id", import_watermelondb25.Q.oneOf(ids))).fetch();
+          const rows = fromSourceConversation ? [] : await messagePositions(storage, ids);
           const foreignRows = new Set(
-            rows.filter((row) => row._getRaw("conversation_id") !== conversationId).map((row) => row.id)
+            rows.filter((row) => row.conversation_id !== conversationId).map((row) => row.id)
           );
           const sequences = /* @__PURE__ */ new Map();
           if (fromSourceConversation) {
@@ -35968,7 +35984,7 @@ function createDurableAutoExtractor(options) {
           }
           for (const row of rows) {
             if (foreignRows.has(row.id)) continue;
-            const sequence = Number(row._getRaw("message_id"));
+            const sequence = Number(row.message_id);
             if (Number.isFinite(sequence) && sequence > 0) sequences.set(row.id, sequence);
           }
           let boundary = -1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anuma/sdk",
-  "version": "9.1.2",
+  "version": "9.1.4",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",