@anuma/sdk 7.0.1 → 7.0.2

package/dist/react/index.cjs

@@ -3585,6 +3585,35 @@ function decodeChunkVector(vector, onMalformed) {
   }
 }
 
+// src/lib/scheduling.ts
+function nowMs() {
+  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
+}
+function yieldToEventLoop() {
+  const scheduler = globalThis.scheduler;
+  if (typeof scheduler?.yield === "function") return scheduler.yield();
+  if (typeof MessageChannel === "function") {
+    return new Promise((resolve) => {
+      const channel = new MessageChannel();
+      channel.port1.onmessage = () => {
+        channel.port1.close();
+        channel.port2.close();
+        resolve();
+      };
+      channel.port2.postMessage(null);
+    });
+  }
+  return new Promise((resolve) => setTimeout(resolve, 0));
+}
+function createTimeSliceYielder(budgetMs) {
+  let sliceStart = nowMs();
+  return async () => {
+    if (nowMs() - sliceStart < budgetMs) return;
+    await yieldToEventLoop();
+    sliceStart = nowMs();
+  };
+}
+
 // src/lib/db/encryption-utils.ts
 init_logger();
 var ENCRYPTION_PREFIX = "enc:v3:";
@@ -4968,6 +4997,95 @@ async function searchMessagesOp(ctx, queryVector, options) {
     })
   );
 }
+var CHUNK_VECTOR_BATCH_SIZE = 50;
+var CHUNK_SCAN_YIELD_BUDGET_MS = 12;
+var hasEmbeddingSql = `(coalesce("chunks", '') != '' or coalesce("vector", '') != '')`;
+function toChunkCandidateKey(raw) {
+  return {
+    id: raw.id,
+    conversationId: String(raw.conversation_id),
+    version: Number(raw.updated_at) || 0,
+    embeddingModel: raw.embedding_model ?? null
+  };
+}
+async function fetchRowsByIds(ctx, ids) {
+  if (ids.length === 0) return [];
+  return await ctx.messagesCollection.query(import_watermelondb2.Q.where("id", import_watermelondb2.Q.oneOf(ids))).unsafeFetchRaw();
+}
+async function projectedChunkRowSource(ctx, filter) {
+  const clauses = [
+    `"history"."_status" is not 'deleted'`,
+    hasEmbeddingSql,
+    `exists (select 1 from "conversations" where "conversations"."conversation_id" = "history"."conversation_id" and "conversations"."is_deleted" = 0 and "conversations"."_status" is not 'deleted')`
+  ];
+  const args = [];
+  if (filter.conversationId !== void 0) {
+    clauses.push(`"history"."conversation_id" = ?`);
+    args.push(filter.conversationId);
+  }
+  if (filter.excludeConversationId !== void 0) {
+    clauses.push(`"history"."conversation_id" != ?`);
+    args.push(filter.excludeConversationId);
+  }
+  const keyRows = await ctx.messagesCollection.query(
+    import_watermelondb2.Q.unsafeSqlQuery(
+      `select "id", "conversation_id", "updated_at", "embedding_model" from "history" where ${clauses.join(" and ")}`,
+      args
+    )
+  ).unsafeFetchRaw();
+  return {
+    keys: keyRows.map(toChunkCandidateKey),
+    loadVectorRows: async (ids) => {
+      if (ids.length === 0) return [];
+      return await ctx.messagesCollection.query(
+        import_watermelondb2.Q.unsafeSqlQuery(
+          `select "id", "updated_at", "chunks", "vector" from "history" where "_status" is not 'deleted' and "id" in (${ids.map(() => "?").join(",")})`,
+          ids
+        )
+      ).unsafeFetchRaw();
+    },
+    loadFullRows: (ids) => fetchRowsByIds(ctx, ids)
+  };
+}
+async function fullScanChunkRowSource(ctx, filter) {
+  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb2.Q.where("is_deleted", false)).fetch();
+  const activeConversationIds = new Set(
+    activeConversations.map((c) => String(c._getRaw("conversation_id")))
+  );
+  const queryConditions = filter.conversationId !== void 0 ? [import_watermelondb2.Q.where("conversation_id", filter.conversationId)] : [];
+  const rows = await ctx.messagesCollection.query(...queryConditions).unsafeFetchRaw();
+  const rowsById = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    const conversationId = String(row.conversation_id);
+    if (!activeConversationIds.has(conversationId)) continue;
+    if (filter.excludeConversationId !== void 0 && conversationId === filter.excludeConversationId) {
+      continue;
+    }
+    if (!row.chunks && !row.vector) continue;
+    rowsById.set(row.id, row);
+  }
+  const pick = (ids) => Promise.resolve(
+    ids.flatMap((id) => {
+      const row = rowsById.get(id);
+      return row ? [row] : [];
+    })
+  );
+  return {
+    keys: Array.from(rowsById.values(), toChunkCandidateKey),
+    loadVectorRows: pick,
+    loadFullRows: pick
+  };
+}
+async function chunkRowSource(ctx, filter) {
+  try {
+    return await projectedChunkRowSource(ctx, filter);
+  } catch (err) {
+    getLogger().debug(
+      "searchChunksOp: projected SQL unavailable, using full-load fallback: " + (err instanceof Error ? err.message : String(err))
+    );
+    return fullScanChunkRowSource(ctx, filter);
+  }
+}
 async function searchChunksOp(ctx, queryVector, options) {
   const {
     limit = 10,
@@ -4975,83 +5093,111 @@ async function searchChunksOp(ctx, queryVector, options) {
     conversationId,
     excludeConversationId,
     embeddingModel,
-    chunkCache
+    chunkCache,
+    onStats
   } = options || {};
-  const activeConversations = await ctx.conversationsCollection.query(import_watermelondb2.Q.where("is_deleted", false)).fetch();
-  const activeConversationIds = new Set(
-    activeConversations.map((c) => String(c._getRaw("conversation_id")))
-  );
-  const queryConditions = conversationId ? [import_watermelondb2.Q.where("conversation_id", conversationId)] : [];
-  const messages = await ctx.messagesCollection.query(...queryConditions).unsafeFetchRaw();
+  const source = await chunkRowSource(ctx, { conversationId, excludeConversationId });
+  const yieldIfDue = createTimeSliceYielder(CHUNK_SCAN_YIELD_BUDGET_MS);
   const candidates = [];
   let staleSkipped = 0;
   let unreadableVectors = 0;
-  for (const message of messages) {
-    const msgConvId = String(message.conversation_id);
-    if (!activeConversationIds.has(msgConvId)) continue;
-    if (excludeConversationId !== void 0 && msgConvId === excludeConversationId) continue;
-    if (embeddingModel) {
-      const storedModel = message.embedding_model;
-      if (storedModel !== null && storedModel !== void 0 && storedModel !== embeddingModel) {
-        staleSkipped++;
-        continue;
-      }
+  let cacheHits = 0;
+  const missIds = [];
+  const orderById = /* @__PURE__ */ new Map();
+  for (const [order, key] of source.keys.entries()) {
+    await yieldIfDue();
+    orderById.set(key.id, order);
+    if (embeddingModel && key.embeddingModel !== null && key.embeddingModel !== embeddingModel) {
+      staleSkipped++;
+      continue;
     }
-    const version = Number(message.updated_at) || 0;
-    const cached = chunkCache?.get(message.id);
-    if (cached && cached.version === version) {
-      if (cached.chunks.length > 0) {
-        for (let ci = 0; ci < cached.chunks.length; ci++) {
-          const vec = cached.chunks[ci];
-          if (vec.length === 0) continue;
-          const similarity = cosineSimilarity(queryVector, vec);
-          if (similarity >= minSimilarity) {
-            candidates.push({
-              message,
-              similarity,
-              chunkTextSource: { kind: "chunk-cached", chunkIndex: ci, version }
-            });
-          }
-        }
-      } else if (cached.fallback) {
-        const similarity = cosineSimilarity(queryVector, cached.fallback);
-        if (similarity >= minSimilarity) {
-          candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
-        }
-      }
+    const cached = chunkCache?.get(key.id);
+    if (!cached || cached.version !== key.version) {
+      missIds.push(key.id);
       continue;
     }
-    const chunks3 = await readRawJsonField(message, "chunks", ctx.walletAddress);
-    if (chunks3 && chunks3.length > 0) {
-      const vectors = chunks3.map(
-        (chunk) => decodeChunkVector(chunk.vector, () => {
-          unreadableVectors++;
-        })
-      );
-      chunkCache?.set(message.id, { version, chunks: vectors });
-      for (let ci = 0; ci < chunks3.length; ci++) {
-        const vec = vectors[ci];
+    cacheHits++;
+    if (cached.chunks.length > 0) {
+      for (let ci = 0; ci < cached.chunks.length; ci++) {
+        const vec = cached.chunks[ci];
         if (vec.length === 0) continue;
         const similarity = cosineSimilarity(queryVector, vec);
         if (similarity >= minSimilarity) {
           candidates.push({
-            message,
+            id: key.id,
+            version: key.version,
+            order,
             similarity,
-            chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+            chunkTextSource: { kind: "chunk-cached", chunkIndex: ci, version: key.version }
           });
         }
       }
-    } else {
-      const messageVector = await readRawJsonField(message, "vector", ctx.walletAddress);
-      if (!messageVector || messageVector.length === 0) continue;
-      const fallback = Float32Array.from(messageVector);
-      chunkCache?.set(message.id, { version, chunks: [], fallback });
-      const similarity = cosineSimilarity(queryVector, fallback);
+    } else if (cached.fallback) {
+      const similarity = cosineSimilarity(queryVector, cached.fallback);
       if (similarity >= minSimilarity) {
-        candidates.push({ message, similarity, chunkTextSource: { kind: "message" } });
+        candidates.push({
+          id: key.id,
+          version: key.version,
+          order,
+          similarity,
+          chunkTextSource: { kind: "message" }
+        });
+      }
+    }
+  }
+  let rowsFetched = 0;
+  for (let offset = 0; offset < missIds.length; offset += CHUNK_VECTOR_BATCH_SIZE) {
+    const rows = await source.loadVectorRows(
+      missIds.slice(offset, offset + CHUNK_VECTOR_BATCH_SIZE)
+    );
+    rowsFetched += rows.length;
+    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 chunks3 = await readRawJsonField(row, "chunks", ctx.walletAddress);
+      if (chunks3 && chunks3.length > 0) {
+        const vectors = chunks3.map(
+          (chunk) => decodeChunkVector(chunk.vector, () => {
+            unreadableVectors++;
+          })
+        );
+        chunkCache?.set(id, { 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,
+              version,
+              order,
+              similarity,
+              chunkTextSource: { kind: "chunk", chunk: chunks3[ci], siblings: chunks3 }
+            });
+          }
+        }
+      } 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" }
+            });
+          }
+        }
       }
     }
   }
+  onStats?.({ rowsScanned: source.keys.length, rowsFetched, cacheHits });
   if (staleSkipped > 0) {
     getLogger().warn(
       `searchChunksOp: skipped ${staleSkipped} messages whose embedding model differs from the current model (${embeddingModel}) \u2014 re-embed via chunkAndEmbedAllMessages`
@@ -5062,12 +5208,17 @@ async function searchChunksOp(ctx, queryVector, options) {
       `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`
     );
   }
-  const topK = candidates.sort((a, b) => b.similarity - a.similarity).slice(0, limit);
-  const uniqueMessages = /* @__PURE__ */ new Map();
-  for (const c of topK) uniqueMessages.set(c.message.id, c.message);
+  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);
+  const rowById = new Map(fullRows.map((row) => [row.id, row]));
+  const liveTopK = topK.filter((c) => {
+    const row = rowById.get(c.id);
+    return row !== void 0 && (Number(row.updated_at) || 0) === c.version;
+  });
   const storedById = new Map(
     await Promise.all(
-      Array.from(uniqueMessages, async ([id, m]) => {
+      Array.from(rowById, async ([id, m]) => {
         const stored2 = await messageRawToStored(
           m,
           ctx.walletAddress,
@@ -5080,24 +5231,24 @@ async function searchChunksOp(ctx, queryVector, options) {
   );
   const chunkStateByMsgId = /* @__PURE__ */ new Map();
   const needsChunkText = /* @__PURE__ */ new Set();
-  for (const c of topK) {
-    if (c.chunkTextSource.kind === "chunk-cached") needsChunkText.add(c.message.id);
+  for (const c of liveTopK) {
+    if (c.chunkTextSource.kind === "chunk-cached") needsChunkText.add(c.id);
   }
   await Promise.all(
     Array.from(needsChunkText, async (id) => {
-      const m = uniqueMessages.get(id);
+      const m = rowById.get(id);
       const parsed = await readRawJsonField(m, "chunks", ctx.walletAddress);
       const version = Number(m.updated_at) || 0;
       if (parsed) chunkStateByMsgId.set(id, { version, chunks: parsed });
     })
   );
-  return topK.map(({ message, similarity, chunkTextSource }) => {
-    const stored2 = { ...storedById.get(message.id) };
+  return liveTopK.map(({ id, similarity, chunkTextSource }) => {
+    const stored2 = { ...storedById.get(id) };
     let chunkText2;
     if (chunkTextSource.kind === "chunk") {
       chunkText2 = resolveChunkText(stored2.content, chunkTextSource.chunk, chunkTextSource.siblings);
     } else if (chunkTextSource.kind === "chunk-cached") {
-      const state = chunkStateByMsgId.get(message.id);
+      const state = chunkStateByMsgId.get(id);
       const chunk = state && state.version === chunkTextSource.version ? state.chunks[chunkTextSource.chunkIndex] : void 0;
       chunkText2 = resolveChunkText(stored2.content, chunk, state?.chunks);
     } else {
@@ -6257,13 +6408,35 @@ async function generateEmbedding(text14, options) {
   if (total === void 0) return embedOne(text14, options, void 0);
   return withDeadline((signal) => embedOne(text14, options, signal), total, "embedding");
 }
+var inFlightByCache = /* @__PURE__ */ new WeakMap();
 async function embedOne(text14, options, outer) {
-  const { baseUrl = BASE_URL, model, cache } = options;
-  const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_REQUEST_TIMEOUT_MS;
-  if (cache) {
-    const cached = cache.get(text14);
-    if (cached) return Array.from(cached);
+  const { cache } = options;
+  if (!cache) return Array.from(await requestEmbedding(text14, options, outer));
+  const cached = cache.get(text14);
+  if (cached) return Array.from(cached);
+  const inFlight = inFlightByCache.get(cache) ?? /* @__PURE__ */ new Map();
+  inFlightByCache.set(cache, inFlight);
+  const pending = inFlight.get(text14);
+  if (pending) {
+    try {
+      return Array.from(await pending);
+    } catch (err) {
+      if (outer?.aborted) throw err;
+    }
+  }
+  const request = requestEmbedding(text14, options, outer);
+  inFlight.set(text14, request);
+  try {
+    const embedding2 = await request;
+    cache.set(text14, embedding2);
+    return Array.from(embedding2);
+  } finally {
+    if (inFlight.get(text14) === request) inFlight.delete(text14);
   }
+}
+async function requestEmbedding(text14, options, outer) {
+  const { baseUrl = BASE_URL, model } = options;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_EMBEDDING_REQUEST_TIMEOUT_MS;
   const headers = {
     ...await resolveAuthHeaders(options, outer),
     ...taskTypeHeader(options.taskType)
@@ -6298,11 +6471,7 @@ async function embedOne(text14, options, outer) {
       totalTokens: response.data.usage.total_tokens ?? 0
     });
   }
-  const f32Embedding = Float32Array.from(embedding2);
-  if (cache) {
-    cache.set(text14, f32Embedding);
-  }
-  return Array.from(f32Embedding);
+  return Float32Array.from(embedding2);
 }
 var DEFAULT_EMBEDDING_BATCH_SIZE = 100;
 var DEFAULT_EMBEDDING_BATCH_CONCURRENCY = 3;
@@ -17619,9 +17788,9 @@ function recencyMultiplier(updatedAt, opts = {}) {
   const updatedMs = updatedAt.getTime();
   if (!Number.isFinite(updatedMs)) return noDate;
   const now = opts.now ?? /* @__PURE__ */ new Date();
-  const nowMs3 = now.getTime();
-  if (!Number.isFinite(nowMs3)) return noDate;
-  const ageDays2 = Math.max(0, (nowMs3 - updatedMs) / DAY_MS2);
+  const nowMs2 = now.getTime();
+  if (!Number.isFinite(nowMs2)) return noDate;
+  const ageDays2 = Math.max(0, (nowMs2 - updatedMs) / DAY_MS2);
   const perYearDecay = opts.perYearDecay ?? DEFAULT_PER_YEAR_DECAY;
   const floor = opts.floor ?? DEFAULT_FLOOR;
   const decay = perYearDecay * (ageDays2 / 365);
@@ -18133,9 +18302,6 @@ function createVaultEmbeddingCache(maxSize = DEFAULT_VAULT_CACHE_SIZE) {
 
 // src/lib/memoryVault/searchTool.ts
 var DEFAULT_RERANK_TOP_N = 5;
-function nowMs() {
-  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
 var warnedProgrammaticDecomposeIgnored = false;
 function normalizeEventTimeKind(kind) {
   return kind === "point" || kind === "range" || kind === "ongoing" ? kind : null;
@@ -21037,6 +21203,32 @@ function rankProfileCandidates(inputs, now = Date.now(), options = {}) {
   return ranked;
 }
 
+// src/lib/db/chat/embeddingCache.ts
+var MaskScopedEmbeddingCache = class extends Map {
+  constructor(inner, masked) {
+    super();
+    this.inner = inner;
+    this.masked = masked;
+  }
+  key(text14) {
+    return `${this.masked ? "m" : "r"}:${text14}`;
+  }
+  get(text14) {
+    return this.inner.get(this.key(text14));
+  }
+  set(text14, value) {
+    this.inner.set(this.key(text14), value);
+    return this;
+  }
+};
+var scopedViews = /* @__PURE__ */ new WeakMap();
+function maskScopedEmbeddingCache(cache, masked) {
+  const views = scopedViews.get(cache) ?? {};
+  scopedViews.set(cache, views);
+  const slot = masked ? "masked" : "raw";
+  return views[slot] ?? (views[slot] = new MaskScopedEmbeddingCache(cache, masked));
+}
+
 // src/lib/memory/recall.ts
 init_logger();
 
@@ -21247,9 +21439,6 @@ function scoreEventTimeOverlap(memoryStart, memoryEnd, memoryKind, window2) {
 var DEFAULT_LIMIT = 8;
 var DEFAULT_BUDGET = "low";
 var DEFAULT_FACT_MIN_SCORE = 0.1;
-function nowMs2() {
-  return typeof performance !== "undefined" && typeof performance.now === "function" ? performance.now() : Date.now();
-}
 var DEFAULT_CHUNK_MIN_SCORE = 0.5;
 var DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS = 8e3;
 function flagsForBudget(budget) {
@@ -21287,12 +21476,19 @@ async function recall(query, ctx, options = {}) {
   const subQueries = normalizedFacets.length >= 2 ? normalizedFacets : void 0;
   const embeddingOptions = {
     ...ctx.embeddingOptions,
-    taskType: "memory_recall_embed"
+    taskType: "memory_recall_embed",
+    ...options.embeddingCache && !ctx.embeddingOptions.cache && {
+      cache: maskScopedEmbeddingCache(
+        options.embeddingCache,
+        Boolean(ctx.embeddingOptions.maskInput)
+      )
+    }
   };
-  const t0 = nowMs2();
+  const t0 = nowMs();
   let prepMs = 0;
   let factLaneMs = 0;
   let chunkLaneMs = 0;
+  let chunkStats;
   let fuseMs = 0;
   const factResults = [];
   const chunkResults = [];
@@ -21347,6 +21543,11 @@ async function recall(query, ctx, options = {}) {
       ...decryptLastRan !== void 0 && { decryptLast: decryptLastRan },
       ...vaultRowsDecrypted !== void 0 && { vaultRowsDecrypted },
       ...vaultRowsEmbedded !== void 0 && { vaultRowsEmbedded },
+      ...chunkStats && {
+        chunkRowsScanned: chunkStats.rowsScanned,
+        chunkRowsFetched: chunkStats.rowsFetched,
+        chunkCacheHits: chunkStats.cacheHits
+      },
       factCount: factResults.length,
       chunkCount: chunkResults.length,
       admittedCount: admitted.length,
@@ -21358,7 +21559,7 @@ async function recall(query, ctx, options = {}) {
       temporalLaneCount,
       emptyReason: emptyReasonFor(admitted.length, laneRan),
       timings: {
-        total: nowMs2() - t0,
+        total: nowMs() - t0,
         prep: prepMs,
         factLane: factLaneMs,
         rerank: rerankMs,
@@ -21380,14 +21581,14 @@ async function recall(query, ctx, options = {}) {
   const needsChunkEmbedding = types.includes("chunk") && ctx.storageCtx;
   const wantsTemporal = types.includes("fact") && (ctx.factSource || ctx.vaultCtx);
   const queryEmbedTotalTimeoutMs = options.queryEmbedTotalTimeoutMs ?? DEFAULT_QUERY_EMBED_TOTAL_TIMEOUT_MS;
-  const prepStart = nowMs2();
+  const prepStart = nowMs();
   let sharedEmbedMs = 0;
   const [queryEmbedding, entityRanking, temporalRanking] = await Promise.all([
     needsChunkEmbedding ? generateEmbedding(query, {
       ...embeddingOptions,
       totalTimeoutMs: queryEmbedTotalTimeoutMs
     }).finally(() => {
-      sharedEmbedMs = nowMs2() - prepStart;
+      sharedEmbedMs = nowMs() - prepStart;
     }).then((vec) => {
       if (vec.length === 0) {
         getLogger().warn(
@@ -21420,11 +21621,11 @@ async function recall(query, ctx, options = {}) {
       () => ctx.factSource ? ctx.factSource.temporalRanking(query, options.now) : buildTemporalLaneRanking(query, ctx.vaultCtx, options.now)
     ) : Promise.resolve([])
   ]);
-  prepMs = nowMs2() - prepStart;
+  prepMs = nowMs() - prepStart;
   graphLaneCount = entityRanking.length;
   temporalLaneCount = temporalRanking.length;
   if (types.includes("fact") && (ctx.factSource || ctx.vaultCtx && ctx.vaultCache)) {
-    const factStart = nowMs2();
+    const factStart = nowMs();
     const vaultMinScore = options.minScore ?? DEFAULT_FACT_MIN_SCORE;
     factFloor = vaultMinScore;
     const {
@@ -21500,11 +21701,11 @@ async function recall(query, ctx, options = {}) {
     factLaneRankedOnCosine = factRankedOnCosine;
     decryptLastRan = factDecryptLast;
     vaultRowsDecrypted = factRowsDecrypted;
-    factLaneMs = nowMs2() - factStart;
+    factLaneMs = nowMs() - factStart;
   }
   if (chunkEmbedFailed && !factLaneRankedOnCosine) embeddingsUnavailable = true;
   if (types.includes("chunk") && ctx.storageCtx && queryEmbedding) {
-    const chunkStart = nowMs2();
+    const chunkStart = nowMs();
     const chunkMinScore = options.minScore ?? DEFAULT_CHUNK_MIN_SCORE;
     chunkFloor = chunkMinScore;
     const results = await searchChunksOp(ctx.storageCtx, queryEmbedding, {
@@ -21515,12 +21716,15 @@ async function recall(query, ctx, options = {}) {
       ...options.excludeConversationId && {
         excludeConversationId: options.excludeConversationId
       },
-      ...ctx.chunkCache && { chunkCache: ctx.chunkCache }
+      ...ctx.chunkCache && { chunkCache: ctx.chunkCache },
+      onStats: (stats) => {
+        chunkStats = stats;
+      }
     });
     chunkResults.push(...dedupeBy(results, (r) => r.chunkText.trim()));
-    chunkLaneMs = nowMs2() - chunkStart;
+    chunkLaneMs = nowMs() - chunkStart;
   }
-  const fuseStart = nowMs2();
+  const fuseStart = nowMs();
   if (types.length === 1 || factResults.length === 0 || chunkResults.length === 0) {
     const memories2 = [
       ...factResults.map((r) => toFactMemory(r, options.now)),
@@ -21528,7 +21732,7 @@ async function recall(query, ctx, options = {}) {
     ];
     memories2.sort((a, b) => b.score - a.score);
     const candidateCount = factResults.length + chunkResults.length;
-    fuseMs = nowMs2() - fuseStart;
+    fuseMs = nowMs() - fuseStart;
     const admitted = memories2.slice(0, limit);
     hitLimit = memories2.length > limit;
     emitDiagnostics(candidateCount, admitted);
@@ -21592,7 +21796,7 @@ async function recall(query, ctx, options = {}) {
     memories = selection.out;
   }
   hitLimit = selection.cut;
-  fuseMs = nowMs2() - fuseStart;
+  fuseMs = nowMs() - fuseStart;
   emitDiagnostics(byId.size, memories);
   return {
     memories,
@@ -31612,28 +31816,6 @@ async function cleanupConversationSummary(database, conversationId) {
   }
 }
 
-// src/lib/db/chat/embeddingCache.ts
-var MaskScopedEmbeddingCache = class extends Map {
-  constructor(inner, masked) {
-    super();
-    this.inner = inner;
-    this.masked = masked;
-  }
-  key(text14) {
-    return `${this.masked ? "m" : "r"}:${text14}`;
-  }
-  get(text14) {
-    return this.inner.get(this.key(text14));
-  }
-  set(text14, value) {
-    this.inner.set(this.key(text14), value);
-    return this;
-  }
-};
-function maskScopedEmbeddingCache(cache, masked) {
-  return new MaskScopedEmbeddingCache(cache, masked);
-}
-
 // src/react/useChatStorage.ts
 init_logger();
 init_redactor();