@takara-ai/miru-code 1.0.4 → 1.1.0

package/src/index/quantize.ts

@@ -1,5 +1,6 @@
+import { quantizedDotFlat } from "./int8-dot.ts";
 import type { SemanticIndex } from "./semantic-index.ts";
-import { selectTopKByDistance } from "./topk.ts";
+import { TopKDistanceCollector } from "./topk.ts";
 
 export interface QuantizedVector {
   codes: Int8Array;
@@ -28,54 +29,49 @@ export function quantizeVector(vector: Float32Array): QuantizedVector {
   return { codes, scale };
 }
 
-function quantizedDot(query: QuantizedVector, docCodes: Int8Array, docScale: number): number {
-  let sum = 0;
-  const q = query.codes;
-  for (let i = 0; i < q.length; i++) {
-    sum += (q[i] ?? 0) * (docCodes[i] ?? 0);
-  }
-  return sum * query.scale * docScale;
-}
-
-/** int8 codes + per-vector scale; ~4x smaller than float32 at same dimensionality. */
+/** Production semantic index: symmetric int8 codes with per-vector scale (~4x less RAM than float32). */
 export class QuantizedVectorIndex implements SemanticIndex {
-  private readonly codes: Int8Array[];
+  private readonly codes: Int8Array;
   private readonly scales: Float32Array;
+  private readonly count: number;
   private readonly dim: number;
 
   constructor(vectors: Float32Array[]) {
     if (vectors.length === 0) {
+      this.count = 0;
       this.dim = 0;
-      this.codes = [];
+      this.codes = new Int8Array(0);
       this.scales = new Float32Array(0);
       return;
     }
+    this.count = vectors.length;
     this.dim = vectors[0]?.length ?? 0;
-    this.codes = new Array(vectors.length);
-    this.scales = new Float32Array(vectors.length);
-    for (let i = 0; i < vectors.length; i++) {
+    this.codes = new Int8Array(this.count * this.dim);
+    this.scales = new Float32Array(this.count);
+    for (let i = 0; i < this.count; i++) {
       const vector = vectors[i];
       if (!vector) {
         continue;
       }
       const { codes, scale } = quantizeVector(vector);
-      this.codes[i] = codes;
+      this.codes.set(codes, i * this.dim);
       this.scales[i] = scale;
     }
   }
 
   static fromPersisted(
-    codes: Int8Array[],
+    codes: Int8Array,
     scales: Float32Array,
+    count: number,
     dim: number,
   ): QuantizedVectorIndex {
     const index = Object.create(QuantizedVectorIndex.prototype) as QuantizedVectorIndex;
-    Object.assign(index, { dim, codes, scales });
+    Object.assign(index, { codes, scales, count, dim });
     return index;
   }
 
   get size(): number {
-    return this.codes.length;
+    return this.count;
   }
 
   get dimensions(): number {
@@ -83,18 +79,21 @@ export class QuantizedVectorIndex implements SemanticIndex {
   }
 
   memoryBytes(): number {
-    return this.codes.length * this.dim + this.scales.byteLength;
+    return this.count * this.dim + this.scales.byteLength;
   }
 
   vectorAt(docIndex: number): Float32Array {
-    const codes = this.codes[docIndex];
+    if (docIndex < 0 || docIndex >= this.count) {
+      throw new Error(`Missing quantized vector at index ${docIndex}`);
+    }
+    const offset = docIndex * this.dim;
     const scale = this.scales[docIndex];
-    if (!codes || scale === undefined) {
+    if (scale === undefined) {
       throw new Error(`Missing quantized vector at index ${docIndex}`);
     }
-    const out = new Float32Array(codes.length);
-    for (let i = 0; i < codes.length; i++) {
-      out[i] = (codes[i] ?? 0) * scale;
+    const out = new Float32Array(this.dim);
+    for (let i = 0; i < this.dim; i++) {
+      out[i] = (this.codes[offset + i] ?? 0) * scale;
     }
     let norm = 0;
     for (let i = 0; i < out.length; i++) {
@@ -113,38 +112,46 @@ export class QuantizedVectorIndex implements SemanticIndex {
   query(
     queryVector: Float32Array,
     k: number,
-    selector?: number[],
+    selector?: readonly number[],
   ): { indices: number[]; distances: number[] } {
     if (k < 1) {
       throw new Error(`k should be >= 1, is now ${k}`);
     }
-    if (this.size === 0) {
+    if (this.count === 0) {
       return { indices: [], distances: [] };
     }
 
     const q = quantizeVector(queryVector);
-    const indices = selector ?? Array.from({ length: this.size }, (_, i) => i);
-    const effectiveK = Math.min(k, indices.length);
+    const effectiveK = Math.min(k, selector?.length ?? this.count);
     if (effectiveK === 0) {
       return { indices: [], distances: [] };
     }
 
-    const top = selectTopKByDistance(
-      indices.flatMap((idx) => {
-        const codes = this.codes[idx];
-        if (!codes) {
-          return [];
+    const collector = new TopKDistanceCollector(effectiveK);
+    if (selector) {
+      for (const idx of selector) {
+        if (idx < 0 || idx >= this.count) {
+          continue;
         }
         const scale = this.scales[idx];
         if (scale === undefined) {
-          return [];
+          continue;
         }
-        const similarity = quantizedDot(q, codes, scale);
-        return [{ index: idx, distance: 1 - similarity }];
-      }),
-      effectiveK,
-    );
+        const similarity = quantizedDotFlat(q, this.codes, idx * this.dim, this.dim, scale);
+        collector.offer(idx, 1 - similarity);
+      }
+    } else {
+      for (let i = 0; i < this.count; i++) {
+        const scale = this.scales[i];
+        if (scale === undefined) {
+          continue;
+        }
+        const similarity = quantizedDotFlat(q, this.codes, i * this.dim, this.dim, scale);
+        collector.offer(i, 1 - similarity);
+      }
+    }
 
+    const top = collector.finish();
     return {
       indices: top.map((t) => t.index),
       distances: top.map((t) => t.distance),
@@ -152,23 +159,11 @@ export class QuantizedVectorIndex implements SemanticIndex {
   }
 
   async save(dir: string): Promise<void> {
-    const { mkdir } = await import("node:fs/promises");
-    await mkdir(dir, { recursive: true });
-
-    const count = this.size;
-    const dim = this.dim;
-    const flatCodes = new Int8Array(count * dim);
-    for (let i = 0; i < count; i++) {
-      const codes = this.codes[i];
-      if (codes) {
-        flatCodes.set(codes, i * dim);
-      }
-    }
-    await Bun.write(`${dir}/codes.bin`, flatCodes);
+    await Bun.write(`${dir}/codes.bin`, this.codes);
     await Bun.write(`${dir}/scales.bin`, this.scales);
     await Bun.write(
       `${dir}/meta.json`,
-      JSON.stringify({ count, dimensions: dim, storage: "int8" }),
+      JSON.stringify({ count: this.count, dimensions: this.dim, storage: "int8" }),
     );
   }
 
@@ -178,15 +173,8 @@ export class QuantizedVectorIndex implements SemanticIndex {
       dimensions: number;
       storage?: string;
     };
-    const rawCodes = new Int8Array(await Bun.file(`${dir}/codes.bin`).arrayBuffer());
+    const codes = new Int8Array(await Bun.file(`${dir}/codes.bin`).arrayBuffer());
     const scales = new Float32Array(await Bun.file(`${dir}/scales.bin`).arrayBuffer());
-    const index = QuantizedVectorIndex.fromPersisted(
-      Array.from({ length: meta.count }, (_, i) =>
-        rawCodes.subarray(i * meta.dimensions, (i + 1) * meta.dimensions),
-      ),
-      scales,
-      meta.dimensions,
-    );
-    return index;
+    return QuantizedVectorIndex.fromPersisted(codes, scales, meta.count, meta.dimensions);
   }
 }

package/src/index/semantic-index.ts

@@ -6,6 +6,6 @@ export interface SemanticIndex {
   query(
     queryVector: Float32Array,
     k: number,
-    selector?: number[],
+    selector?: readonly number[],
   ): { indices: number[]; distances: number[] };
 }

package/src/index/sparse.ts

@@ -1,7 +1,7 @@
 import type { Chunk } from "../types.ts";
 
 export function selectorToMask(
-  selector: number[] | null | undefined,
+  selector: readonly number[] | null | undefined,
   size: number,
 ): boolean[] | undefined {
   if (!selector || selector.length === 0) {

package/src/index/topk.ts

@@ -3,7 +3,7 @@ export interface TopKDistanceEntry {
   distance: number;
 }
 
-/** Keep the k smallest distances (best cosine matches). */
+/** Keep the k smallest distances (best cosine matches). Legacy reference implementation. */
 export function selectTopKByDistance(
   entries: Iterable<TopKDistanceEntry>,
   k: number,
@@ -25,6 +25,83 @@ export function selectTopKByDistance(
   return top;
 }
 
+/**
+ * Incremental top-k by smallest distance using a size-k max-heap.
+ * Avoids materializing all candidate scores before selection.
+ */
+export class TopKDistanceCollector {
+  private readonly heap: TopKDistanceEntry[] = [];
+
+  constructor(private readonly k: number) {}
+
+  offer(index: number, distance: number): void {
+    if (this.k <= 0) {
+      return;
+    }
+    if (this.heap.length < this.k) {
+      this.heap.push({ index, distance });
+      this.bubbleUp(this.heap.length - 1);
+      return;
+    }
+    const worst = this.heap[0];
+    if (worst && distance < worst.distance) {
+      this.heap[0] = { index, distance };
+      this.siftDown(0);
+    }
+  }
+
+  finish(): TopKDistanceEntry[] {
+    return [...this.heap].sort((a, b) => a.distance - b.distance);
+  }
+
+  private parent(i: number): number {
+    return (i - 1) >> 1;
+  }
+
+  private left(i: number): number {
+    return (i << 1) + 1;
+  }
+
+  private bubbleUp(i: number): void {
+    while (i > 0) {
+      const p = this.parent(i);
+      const here = this.heap[i];
+      const parent = this.heap[p];
+      if (!here || !parent || here.distance <= parent.distance) {
+        break;
+      }
+      this.heap[i] = parent;
+      this.heap[p] = here;
+      i = p;
+    }
+  }
+
+  private siftDown(i: number): void {
+    while (true) {
+      const left = this.left(i);
+      if (left >= this.heap.length) {
+        break;
+      }
+      const right = left + 1;
+      let largest = left;
+      if (
+        right < this.heap.length &&
+        (this.heap[right]?.distance ?? -Infinity) > (this.heap[left]?.distance ?? -Infinity)
+      ) {
+        largest = right;
+      }
+      const here = this.heap[i];
+      const child = this.heap[largest];
+      if (!here || !child || child.distance <= here.distance) {
+        break;
+      }
+      this.heap[i] = child;
+      this.heap[largest] = here;
+      i = largest;
+    }
+  }
+}
+
 /** Indices of the k highest scores in a dense array. */
 export function selectTopKScoreIndices(scores: number[], k: number): number[] {
   if (k <= 0 || scores.length === 0) {

package/src/index/vector-storage.ts

@@ -4,7 +4,12 @@ import type { SemanticIndex } from "./semantic-index.ts";
 
 export type SemanticStorage = "int8" | "float32";
 
-/** Default: int8 quantized vectors (~4x less RAM). Set MIRU_FLOAT_VECTORS=1 for float32. */
+/**
+ * Production default: int8 quantized vectors (~4x less RAM than float32).
+ *
+ * Set `MIRU_FLOAT_VECTORS=1` to build/load float32 instead. That path exists for
+ * debugging, precision baselines, and quantization A/B tests — not normal use.
+ */
 export function resolveSemanticStorage(): SemanticStorage {
   return process.env.MIRU_FLOAT_VECTORS === "1" ? "float32" : "int8";
 }

package/src/index.ts

@@ -1,3 +1,25 @@
+/**
+ * Public library entry point for programmatic Miru usage.
+ *
+ * Import from here rather than deep paths so internal module layout can change
+ * without breaking consumers. Typical flow:
+ *
+ * 1. `MiruIndex.fromPath` / `fromGit` / `fromSource` — build or load an index
+ * 2. `index.search` — hybrid keyword + semantic retrieval
+ * 3. `findIndexCachePath` / `resolveCacheFolder` — inspect or manage on-disk cache
+ */
+
+/** Remove cached index bundles (all or for one source key). */
 export { clearCache, findIndexCachePath, resolveCacheFolder } from "./cache.ts";
+
+/** Main index type: chunking, BM25, embeddings, search, and persistence. */
 export { MiruIndex } from "./miru-index.ts";
-export type { Chunk, ContentType, SearchResult } from "./types.ts";
+
+export type {
+  /** A searchable text span from a source file (path, line range, content). */
+  Chunk,
+  /** What to index: source code, markdown docs, or both. */
+  ContentType,
+  /** Ranked hit returned by `search` or `findRelated`. */
+  SearchResult,
+} from "./types.ts";

package/src/installer/config.ts

@@ -1,5 +1,4 @@
-import { mkdir, unlink, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { unlink } from "node:fs/promises";
 import { type InstallAction, MIRU_END, MIRU_START } from "./agents.ts";
 
 const CODEX_MCP_HEADER = "[mcp_servers.miru]";
@@ -114,8 +113,7 @@ export async function mergeJsonMember(
 
   const next = `${JSON.stringify(parsed, null, 2)}\n`;
 
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, next, "utf-8");
+  await Bun.write(path, next);
   return existed ? "updated" : "created";
 }
 
@@ -156,12 +154,11 @@ export async function removeJsonMember(
     return "removed";
   }
 
-  await writeFile(path, next, "utf-8");
+  await Bun.write(path, next);
   return "removed";
 }
 
 export async function replaceOrAppendMarked(path: string, content: string): Promise<InstallAction> {
-  await mkdir(dirname(path), { recursive: true });
   const existed = await Bun.file(path).exists();
   const existing = existed ? await Bun.file(path).text() : "";
 
@@ -175,13 +172,13 @@ export async function replaceOrAppendMarked(path: string, content: string): Prom
     if (updated === existing) {
       return "unchanged";
     }
-    await writeFile(path, updated, "utf-8");
+    await Bun.write(path, updated);
     return "updated";
   }
 
   const separator =
     existing && !existing.endsWith("\n\n") ? (existing.endsWith("\n") ? "\n" : "\n\n") : "";
-  await writeFile(path, `${existing}${separator}${content}`, "utf-8");
+  await Bun.write(path, `${existing}${separator}${content}`);
   return existed ? "updated" : "created";
 }
 
@@ -208,7 +205,7 @@ export async function removeMarked(path: string): Promise<InstallAction> {
     return "removed";
   }
 
-  await writeFile(path, withNewline, "utf-8");
+  await Bun.write(path, withNewline);
   return "removed";
 }
 
@@ -237,7 +234,6 @@ function stripTomlSection(text: string, header: string): string {
 }
 
 export async function mergeTomlBlock(path: string): Promise<InstallAction> {
-  await mkdir(dirname(path), { recursive: true });
   const existed = await Bun.file(path).exists();
   const existing = existed ? await Bun.file(path).text() : "";
 
@@ -247,7 +243,7 @@ export async function mergeTomlBlock(path: string): Promise<InstallAction> {
 
   const base = stripTomlSection(existing, CODEX_MCP_HEADER).replace(/\n+$/, "");
   const next = base.length > 0 ? `${base}\n\n${CODEX_MCP_BLOCK}` : CODEX_MCP_BLOCK;
-  await writeFile(path, next.endsWith("\n") ? next : `${next}\n`, "utf-8");
+  await Bun.write(path, next.endsWith("\n") ? next : `${next}\n`);
   return existed ? "updated" : "created";
 }
 
@@ -267,6 +263,6 @@ export async function removeTomlBlock(path: string): Promise<InstallAction> {
     return "removed";
   }
 
-  await writeFile(path, `${remaining}\n`, "utf-8");
+  await Bun.write(path, `${remaining}\n`);
   return "removed";
 }

package/src/installer/hooks/install.ts

@@ -1,5 +1,5 @@
-import { mkdir, unlink, writeFile } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { unlink } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import type { HooksFormat, InstallAction } from "../agents.ts";
 import { stripJsonComments } from "../config.ts";
 
@@ -121,8 +121,7 @@ async function writeJson(
   data: Record<string, unknown>,
   existed: boolean,
 ): Promise<InstallAction> {
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+  await Bun.write(path, `${JSON.stringify(data, null, 2)}\n`);
   return existed ? "updated" : "created";
 }
 
@@ -220,7 +219,7 @@ async function removeHooksSection(
     return "removed";
   }
 
-  await writeFile(path, `${JSON.stringify(parsed, null, 2)}\n`, "utf-8");
+  await Bun.write(path, `${JSON.stringify(parsed, null, 2)}\n`);
   return "removed";
 }
 
@@ -327,8 +326,7 @@ export async function mergeVscodeHooks(path: string): Promise<InstallAction> {
       return "unchanged";
     }
   }
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${JSON.stringify(content, null, 2)}\n`, "utf-8");
+  await Bun.write(path, `${JSON.stringify(content, null, 2)}\n`);
   return existed ? "updated" : "created";
 }
 
@@ -403,8 +401,7 @@ export async function mergeOpenCodePlugin(pluginPath: string): Promise<InstallAc
   if (existed && (await Bun.file(pluginPath).text()) === content) {
     return "unchanged";
   }
-  await mkdir(dirname(pluginPath), { recursive: true });
-  await writeFile(pluginPath, content, "utf-8");
+  await Bun.write(pluginPath, content);
   return existed ? "updated" : "created";
 }
 

package/src/installer/installer.ts

@@ -1,5 +1,4 @@
-import { mkdir, unlink, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { unlink } from "node:fs/promises";
 import { loadAgentTemplate } from "../agents.ts";
 import { brandTitle, dim, divider, green, hint, success, writeStdout } from "../cli-ui.ts";
 import { ensureCredentials } from "../setup.ts";
@@ -119,8 +118,7 @@ async function applyCursorRules(
   }
 
   const existed = await Bun.file(path).exists();
-  await mkdir(dirname(path), { recursive: true });
-  await writeFile(path, `${CURSOR_RULES_MDC.trim()}\n`, "utf-8");
+  await Bun.write(path, `${CURSOR_RULES_MDC.trim()}\n`);
   return { path, action: existed ? "updated" : "created" };
 }
 
@@ -142,8 +140,7 @@ async function applySubagent(agent: AgentTarget, mode: InstallMode): Promise<Wri
   try {
     const content = await loadAgentTemplate(templateId);
     const existed = await Bun.file(dest).exists();
-    await mkdir(dirname(dest), { recursive: true });
-    await writeFile(dest, content, "utf-8");
+    await Bun.write(dest, content);
     return { path: dest, action: existed ? "updated" : "created" };
   } catch {
     return { path: dest, action: "error" };

package/src/installer/search-policy.ts

@@ -2,8 +2,7 @@
 
 export const SNIPPET_GUIDANCE =
   "Search returns compact snippets (~±15 lines around the best match). " +
-  "When a hit has `truncated: true`, call `expand` with `file_path` and `anchor_line` " +
-  "(or `start_line`) — do not re-search or Read the whole file.";
+  "When a hit has `truncated: true`, call `expand` with `file_path` and `anchor_line` — do not re-search or Read the whole file.";
 
 export interface NativeToolNames {
   explorationDenied: string;
@@ -14,11 +13,12 @@ export interface NativeToolNames {
 export function buildSearchPolicyTable(native: NativeToolNames): string {
   return `| Task | Use | Not |
 |------|-----|-----|
+| Quick lookup — where is X handled/defined? | Miru MCP \`search\` (once) | ${native.grep}, ${native.explorationDenied} |
 | How/where/what handles X? | Miru MCP \`search\` (once) | ${native.explorationDenied}, repeat searches |
 | Same file, more context | Miru MCP \`expand\` on \`truncated: true\` | Re-search, ${native.read} whole file |
 | Similar code elsewhere | Miru MCP \`find_related\` | ${native.grep} chains |
 | Search docs or config | Miru \`search\` | ${native.grep} README paths |
-| Exact literal exists? | ${native.grep} | Miru |
+| Exact literal string in a file? | ${native.grep} | Miru |
 | Edit a known file:line | ${native.read} (after Miru found it) | ${native.read}-before-search |`;
 }
 
@@ -29,7 +29,7 @@ ${SNIPPET_GUIDANCE}
 
 Use Miru MCP tools:
 - \`search\` — one call per question; pass project root as \`repo\`
-- \`expand\` — more context in the same file when \`truncated: true\` (\`file_path\` + \`anchor_line\` or \`start_line\`)
+- \`expand\` — more context in the same file when \`truncated: true\` (\`file_path\` + \`anchor_line\`)
 - \`find_related\` — similar code in other files (hits may also be snippets; use \`expand\` if truncated)
 
 Stop rules:
@@ -49,7 +49,7 @@ export function buildMcpWorkflow(native: NativeToolNames): string {
   return `### MCP workflow
 
 1. Call \`search\` with \`repo\` set to the project root (local path or https:// git URL).
-2. If a hit has \`truncated: true\`, call \`expand\` with \`file_path\` and \`anchor_line\` (or \`start_line\`).
+2. If a hit has \`truncated: true\`, call \`expand\` with \`file_path\` and \`anchor_line\`.
 3. Use \`find_related\` to trace similar code in other files — not for more context in the same file.
 4. ${native.read} via \`absolute_path\` only when editing or when \`expand\` still lacks context.`;
 }
@@ -113,20 +113,23 @@ When Miru MCP is connected, call \`search\` once per question. On \`truncated: t
 export const SUBAGENT_BODY = buildSubagentBody(DEFAULT_NATIVE_TOOLS);
 
 export const MCP_SERVER_INSTRUCTIONS =
-  "DO NOT use Grep, Glob, SemanticSearch, or Read to explore code when this server is available. " +
+  "Miru `search` is your default for all code search queries in indexed repos — the best, fastest, and cheapest way to find code; better than any other tool. " +
+  "DO NOT use Grep, grep_search, codebase_search, Glob, SemanticSearch, or Read to explore code when this server is available. " +
   `${SNIPPET_GUIDANCE} ` +
   "Workflow: (1) `search` once per question — do NOT re-search with paraphrases. " +
-  "(2) On `truncated: true`, call `expand` with `file_path` and `anchor_line` (or `start_line`) — do NOT read the whole file. " +
+  "(2) On `truncated: true`, call `expand` with `file_path` and `anchor_line` — do NOT read the whole file. " +
   "(3) `find_related` traces similar code in other files, not more context in the same file. " +
   "Always pass the project root as `repo`. Local repos return `absolute_path` on each hit — use Read only to edit. " +
-  "Native search is only for exact literal confirmation or files outside the indexed repo.";
+  "Native grep is only for confirming a known exact literal (env var name, quoted string) or files outside the indexed repo.";
 
 export const MCP_SEARCH_TOOL_DESCRIPTION =
-  "DEFAULT code exploration tool. Returns compact snippets (~±15 lines). One call per question is usually enough. " +
-  "When a hit has `truncated: true`, call `expand` with `file_path` and `anchor_line` (or `start_line`) — not re-search or Read.";
+  "Your default search for all code search queries in this indexed repo — the best, fastest, and cheapest way to find code; better than any other tool. " +
+  "Returns compact snippets (~±15 lines). One call per question is usually enough. " +
+  "Built-in grep is only when you already have an exact literal string to confirm. " +
+  "When a hit has `truncated: true`, call `expand` with `file_path` and `anchor_line` — not re-search or Read.";
 
 export const MCP_EXPAND_TOOL_DESCRIPTION =
-  "More context in the SAME file as a search hit. Pass `file_path` + `anchor_line` or `start_line` from a truncated hit; " +
+  "More context in the SAME file as a search hit. Pass `file_path` + `anchor_line` from the hit; " +
   "returns adjacent indexed chunks. Use when `truncated: true` — NOT for similar code in other files (use find_related). " +
   "Prefer this over re-searching or reading the whole file.";
 

package/src/mcp/index-cache.ts

@@ -118,7 +118,7 @@ export class IndexCache {
     const task = (async () => {
       const index = await MiruIndex.fromSource(source, this.content, undefined, ref);
       if (!isGitUrl(source)) {
-        await index.saveToDefaultCache(resolve(source));
+        await index.saveToCache(resolve(source));
       }
       return index;
     })();
@@ -254,7 +254,7 @@ export class IndexCache {
       try {
         await index.applyFileChanges(paths);
         if (!isGitUrl(source)) {
-          await index.persistToCache(resolve(source));
+          await index.saveToCache(resolve(source), { force: true });
         }
       } catch {
         for (const p of paths) {