@anuma/sdk 10.5.2 → 10.5.3

package/dist/expo/index.cjs

@@ -4879,6 +4879,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -4947,45 +5004,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -4996,11 +5047,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -29907,6 +29954,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),

package/dist/expo/index.d.mts

@@ -4436,6 +4436,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;

package/dist/expo/index.d.ts

@@ -4436,6 +4436,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;

package/dist/expo/index.mjs

@@ -3234,6 +3234,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -3302,45 +3359,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -3351,11 +3402,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -28178,6 +28225,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),

package/dist/react/index.cjs

@@ -5619,6 +5619,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -5687,45 +5744,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -5736,11 +5787,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -18392,6 +18439,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),
@@ -38283,6 +38333,7 @@ function useChatStorage(options) {
     [vaultCtx, vaultEmbeddingCache, memoryStore]
   );
   const chunkVectorCacheRef = (0, import_react7.useRef)(createChunkVectorCache());
+  const recallWarmsRef = (0, import_react7.useRef)(/* @__PURE__ */ new Set());
   const clientToolEmbeddingsCacheRef = (0, import_react7.useRef)(/* @__PURE__ */ new Map());
   (0, import_react7.useEffect)(() => {
     if (!getToken || memoryStore !== void 0) return;
@@ -38296,6 +38347,8 @@ function useChatStorage(options) {
   (0, import_react7.useEffect)(() => {
     return onClearAllEncryptionState(() => {
       vaultEmbeddingCache.clear();
+      for (const warm of recallWarmsRef.current) warm.abort();
+      recallWarmsRef.current.clear();
       chunkVectorCacheRef.current.clear();
     });
   }, [vaultEmbeddingCache]);
@@ -38414,6 +38467,28 @@ function useChatStorage(options) {
       storeMaskMissing
     ]
   );
+  const warmRecallCache = (0, import_react7.useCallback)(
+    async (signal) => {
+      if (!backend.warmChunkCache) return 0;
+      const warm = new AbortController();
+      const stop2 = () => warm.abort(signal?.reason);
+      if (signal?.aborted) stop2();
+      signal?.addEventListener("abort", stop2, { once: true });
+      recallWarmsRef.current.add(warm);
+      try {
+        return await backend.warmChunkCache({
+          chunkCache: chunkVectorCacheRef.current,
+          embeddingModel,
+          limit: DEFAULT_CHUNK_CACHE_SIZE,
+          signal: warm.signal
+        });
+      } finally {
+        recallWarmsRef.current.delete(warm);
+        signal?.removeEventListener("abort", stop2);
+      }
+    },
+    [backend, embeddingModel]
+  );
   const {
     isLoading,
     sendMessage: baseSendMessage,
@@ -39596,6 +39671,7 @@ function useChatStorage(options) {
     createMemoryVaultSearchTool: createMemoryVaultSearchTool2,
     createRecallTool: createRecallTool2,
     recall: recallFn,
+    warmRecallCache,
     searchVaultMemories: searchVaultMemoriesFn,
     vaultEmbeddingCache,
     getVaultMemories,

package/dist/react/index.d.mts

@@ -4899,6 +4899,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -13709,6 +13716,7 @@ declare class WatermelonChatStorageAdapter implements ChatBackend {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    warmChunkCache(options: Parameters<NonNullable<ChatBackend["warmChunkCache"]>>[0]): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -15057,6 +15065,11 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
      * @param options - Optional recall configuration (types, budget, limit, scopes, …)
      */
     recall: (query: string, options?: RecallOptions) => Promise<RecallResult>;
+    /**
+     * Loads the most recent past messages' vectors, up to the recall cache's size, so the first recall does not read them all.
+     * @returns How many it added. It resolves rather than rejects when aborted or signed out, with how many it added before stopping.
+     */
+    warmRecallCache: (signal?: AbortSignal) => Promise<number>;
     /**
      * Search vault memories programmatically using semantic similarity.
      * Returns structured results sorted by descending similarity.

package/dist/react/index.d.ts

@@ -4899,6 +4899,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -13709,6 +13716,7 @@ declare class WatermelonChatStorageAdapter implements ChatBackend {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    warmChunkCache(options: Parameters<NonNullable<ChatBackend["warmChunkCache"]>>[0]): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;
@@ -15057,6 +15065,11 @@ interface UseChatStorageResult extends BaseUseChatStorageResult {
      * @param options - Optional recall configuration (types, budget, limit, scopes, …)
      */
     recall: (query: string, options?: RecallOptions) => Promise<RecallResult>;
+    /**
+     * Loads the most recent past messages' vectors, up to the recall cache's size, so the first recall does not read them all.
+     * @returns How many it added. It resolves rather than rejects when aborted or signed out, with how many it added before stopping.
+     */
+    warmRecallCache: (signal?: AbortSignal) => Promise<number>;
     /**
      * Search vault memories programmatically using semantic similarity.
      * Returns structured results sorted by descending similarity.

package/dist/react/index.mjs

@@ -3773,6 +3773,63 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks3 && chunks3.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks3.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks: chunks3
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+async function warmChunkVectorCacheOp(ctx, options) {
+  const { chunkCache, embeddingModel, limit, signal } = options;
+  const source = await chunkRowSource(ctx, {});
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
+  let keys = source.keys.filter(
+    (key3) => !embeddingModel || key3.embeddingModel === null || key3.embeddingModel === embeddingModel
+  );
+  if (limit !== void 0 && keys.length > limit) {
+    keys = keys.sort((a, b) => b.version - a.version).slice(0, limit);
+  }
+  const missIds = [];
+  for (const key3 of keys) {
+    await yieldIfDue();
+    if (chunkCache.get(key3.id)?.version !== key3.version) missIds.push(key3.id);
+  }
+  let warmed = 0;
+  let unreadableVectors = 0;
+  for await (const row of loadVectorRowsInBatches(source, missIds)) {
+    await yieldIfDue();
+    const read = await readChunkVectorRow(ctx, row, () => {
+      unreadableVectors++;
+    });
+    if (signal?.aborted) break;
+    if (!read) continue;
+    chunkCache.set(row.id, read.entry);
+    warmed++;
+  }
+  warnUnreadableChunkVectors("warmChunkVectorCacheOp", unreadableVectors);
+  return warmed;
+}
+async function* loadVectorRowsInBatches(source, ids) {
+  for (let offset = 0; offset < ids.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    yield* await source.loadVectorRows(ids.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE));
+  }
+}
+function warnUnreadableChunkVectors(operation, count2) {
+  if (count2 === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count2} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -3841,45 +3898,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id2 = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id2) ?? Number.MAX_SAFE_INTEGER;
-      const chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks3 && chunks3.length > 0) {
-        const vectors = chunks3.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id2, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks3.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks: chunks3 } = read;
+      const { version } = entry;
+      chunkCache?.set(id2, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id2, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id: id2,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks3.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id: id2,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+          });
         }
       }
     }
@@ -3890,11 +3941,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);
@@ -16522,6 +16569,9 @@ var WatermelonChatStorageAdapter = class {
   searchChunks(queryVector, options) {
     return searchChunksOp(this.ctx, queryVector, options);
   }
+  warmChunkCache(options) {
+    return warmChunkVectorCacheOp(this.ctx, options);
+  }
   getSummary(conversationId) {
     return getConversationSummaryOp(
       createSummaryContext(this.ctx.database, this.ctx),
@@ -36344,6 +36394,7 @@ function useChatStorage(options) {
     [vaultCtx, vaultEmbeddingCache, memoryStore]
   );
   const chunkVectorCacheRef = useRef4(createChunkVectorCache());
+  const recallWarmsRef = useRef4(/* @__PURE__ */ new Set());
   const clientToolEmbeddingsCacheRef = useRef4(/* @__PURE__ */ new Map());
   useEffect5(() => {
     if (!getToken || memoryStore !== void 0) return;
@@ -36357,6 +36408,8 @@ function useChatStorage(options) {
   useEffect5(() => {
     return onClearAllEncryptionState(() => {
       vaultEmbeddingCache.clear();
+      for (const warm of recallWarmsRef.current) warm.abort();
+      recallWarmsRef.current.clear();
       chunkVectorCacheRef.current.clear();
     });
   }, [vaultEmbeddingCache]);
@@ -36475,6 +36528,28 @@ function useChatStorage(options) {
       storeMaskMissing
     ]
   );
+  const warmRecallCache = useCallback6(
+    async (signal) => {
+      if (!backend.warmChunkCache) return 0;
+      const warm = new AbortController();
+      const stop2 = () => warm.abort(signal?.reason);
+      if (signal?.aborted) stop2();
+      signal?.addEventListener("abort", stop2, { once: true });
+      recallWarmsRef.current.add(warm);
+      try {
+        return await backend.warmChunkCache({
+          chunkCache: chunkVectorCacheRef.current,
+          embeddingModel,
+          limit: DEFAULT_CHUNK_CACHE_SIZE,
+          signal: warm.signal
+        });
+      } finally {
+        recallWarmsRef.current.delete(warm);
+        signal?.removeEventListener("abort", stop2);
+      }
+    },
+    [backend, embeddingModel]
+  );
   const {
     isLoading,
     sendMessage: baseSendMessage,
@@ -37657,6 +37732,7 @@ function useChatStorage(options) {
     createMemoryVaultSearchTool: createMemoryVaultSearchTool2,
     createRecallTool: createRecallTool2,
     recall: recallFn,
+    warmRecallCache,
     searchVaultMemories: searchVaultMemoriesFn,
     vaultEmbeddingCache,
     getVaultMemories,

package/dist/server/index.cjs

@@ -19345,6 +19345,28 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks && chunks.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+function warnUnreadableChunkVectors(operation, count) {
+  if (count === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -19413,45 +19435,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id) ?? Number.MAX_SAFE_INTEGER;
-      const chunks = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks && chunks.length > 0) {
-        const vectors = chunks.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks } = read;
+      const { version } = entry;
+      chunkCache?.set(id, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+          });
         }
       }
     }
@@ -19462,11 +19478,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);

package/dist/server/index.d.mts

@@ -4100,6 +4100,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;

package/dist/server/index.d.ts

@@ -4100,6 +4100,13 @@ interface ChatBackend extends ChatStorageAdapter {
         uniqueId: string;
     }): Promise<StoredMessage>;
     searchChunks(queryVector: number[], options?: ChatChunkSearchOptions): Promise<ChunkSearchResult[]>;
+    /** Fills a chunk vector cache ahead of the first search, for backends that score on the device. */
+    warmChunkCache?(options: {
+        chunkCache: ChunkVectorCache;
+        embeddingModel?: string;
+        limit?: number;
+        signal?: AbortSignal;
+    }): Promise<number>;
     getSummary(conversationId: string): Promise<StoredConversationSummary | null>;
     upsertSummary(conversationId: string, summary: string, summarizedUpTo: string, tokenCount: number): Promise<StoredConversationSummary>;
     deleteSummary(conversationId: string): Promise<void>;

package/dist/server/index.mjs

@@ -17637,6 +17637,28 @@ async function chunkRowSource(ctx, filter) {
     return fullScanChunkRowSource(ctx, filter);
   }
 }
+async function readChunkVectorRow(ctx, row, onUnreadable) {
+  const version = Number(row.updated_at) || 0;
+  const chunks = await readRawJsonField(row, "chunks", ctx.walletAddress);
+  if (chunks && chunks.length > 0) {
+    return {
+      entry: {
+        version,
+        chunks: chunks.map((chunk) => decodeChunkVector(chunk.vector, onUnreadable))
+      },
+      chunks
+    };
+  }
+  const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
+  if (!messageVector || messageVector.length === 0) return null;
+  return { entry: { version, chunks: [], fallback: Float32Array.from(messageVector) }, chunks: [] };
+}
+function warnUnreadableChunkVectors(operation, count) {
+  if (count === 0) return;
+  getLogger().warn(
+    `${operation}: could not read ${count} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
+  );
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -17705,45 +17727,39 @@ async function searchChunksOp(ctx, queryVector, options) {
     for (const row of rows) {
       await yieldIfDue();
       const id = row.id;
-      const version = Number(row.updated_at) || 0;
       const order = orderById.get(id) ?? Number.MAX_SAFE_INTEGER;
-      const chunks = await readRawJsonField(row, "chunks", ctx.walletAddress);
-      if (chunks && chunks.length > 0) {
-        const vectors = chunks.map(
-          (chunk) => decodeChunkVector(chunk.vector, () => {
-            unreadableVectors++;
-          })
-        );
-        chunkCache?.set(id, { version, chunks: vectors });
-        for (let ci = 0; ci < chunks.length; ci++) {
-          const vec = vectors[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
-            });
-          }
+      const read = await readChunkVectorRow(ctx, row, () => {
+        unreadableVectors++;
+      });
+      if (!read) continue;
+      const { entry, chunks } = read;
+      const { version } = entry;
+      chunkCache?.set(id, entry);
+      if (entry.fallback) {
+        const similarity = cosineSimilarity(queryVector, entry.fallback);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "message" }
+          });
         }
-      } else {
-        const messageVector = await readRawJsonField(row, "vector", ctx.walletAddress);
-        if (messageVector && messageVector.length > 0) {
-          const fallback = Float32Array.from(messageVector);
-          chunkCache?.set(id, { version, chunks: [], fallback });
-          const similarity = cosineSimilarity(queryVector, fallback);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              id,
-              version,
-              order,
-              similarity,
-              chunkTextSource: { kind: "message" }
-            });
-          }
+        continue;
+      }
+      for (let ci = 0; ci < chunks.length; ci++) {
+        const vec = entry.chunks[ci];
+        if (vec.length === 0) continue;
+        const similarity = cosineSimilarity(queryVector, vec);
+        if (similarity >= minSimilarity) {
+          candidates.push({
+            id,
+            version,
+            order,
+            similarity,
+            chunkTextSource: { kind: "chunk", chunk: chunks[ci], siblings: chunks }
+          });
         }
       }
     }
@@ -17754,11 +17770,7 @@ async function searchChunksOp(ctx, queryVector, options) {
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
     );
   }
-  if (unreadableVectors > 0) {
-    getLogger().warn(
-      `searchChunksOp: could not read ${unreadableVectors} chunk vectors and left them out of ranking \u2014 the stored value is corrupt, so those chunks stay unsearchable until the message is re-embedded via chunkAndEmbedAllMessages`
-    );
-  }
+  warnUnreadableChunkVectors("searchChunksOp", unreadableVectors);
   const topK = candidates.sort((a, b) => b.similarity - a.similarity || a.order - b.order).slice(0, limit);
   const topIds = Array.from(new Set(topK.map((c) => c.id)));
   const fullRows = await source.loadFullRows(topIds);

package/package.json

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