@optave/codegraph 3.4.0 → 3.5.0

package/src/domain/graph/builder/stages/finalize.ts

@@ -3,21 +3,20 @@
  *
  * WASM cleanup, stats logging, drift detection, build metadata, registry, journal.
  */
-import fs from 'node:fs';
+import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import { closeDb, getBuildMeta, setBuildMeta } from '../../../../db/index.js';
+import {
+  closeDbPair,
+  closeDbPairDeferred,
+  getBuildMeta,
+  setBuildMeta,
+} from '../../../../db/index.js';
 import { debug, info, warn } from '../../../../infrastructure/logger.js';
+import { CODEGRAPH_VERSION } from '../../../../shared/version.js';
 import { writeJournalHeader } from '../../journal.js';
 import type { PipelineContext } from '../context.js';
 
-const __builderDir = path.dirname(new URL(import.meta.url).pathname.replace(/^\/([A-Z]:)/i, '$1'));
-const CODEGRAPH_VERSION = (
-  JSON.parse(
-    fs.readFileSync(path.join(__builderDir, '..', '..', '..', '..', '..', 'package.json'), 'utf-8'),
-  ) as { version: string }
-).version;
-
 export async function finalize(ctx: PipelineContext): Promise<void> {
   const { db, allSymbols, rootDir, isFullBuild, hasEmbeddings, config, opts, schemaVersion } = ctx;
 
@@ -46,10 +45,15 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
   info(`Graph built: ${nodeCount} nodes, ${actualEdgeCount} edges`);
   info(`Stored in ${ctx.dbPath}`);
 
-  // Incremental drift detection
-  if (!isFullBuild) {
-    const prevNodes = getBuildMeta(db, 'node_count');
-    const prevEdges = getBuildMeta(db, 'edge_count');
+  // Incremental drift detection — skip for small incremental changes where
+  // count fluctuation is expected (reverse-dep edge churn).
+  if (!isFullBuild && allSymbols.size > 3) {
+    const prevNodes = ctx.nativeDb
+      ? ctx.nativeDb.getBuildMeta('node_count')
+      : getBuildMeta(db, 'node_count');
+    const prevEdges = ctx.nativeDb
+      ? ctx.nativeDb.getBuildMeta('edge_count')
+      : getBuildMeta(db, 'edge_count');
     if (prevNodes && prevEdges) {
       const prevN = Number(prevNodes);
       const prevE = Number(prevEdges);
@@ -67,96 +71,142 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
     }
   }
 
-  // Persist build metadata early so downstream checks (e.g. stale-embeddings)
-  // can read the *current* build's built_at rather than the previous one.
-  try {
-    setBuildMeta(db, {
-      engine: ctx.engineName,
-      engine_version: ctx.engineVersion || '',
-      codegraph_version: CODEGRAPH_VERSION,
-      schema_version: String(schemaVersion),
-      built_at: buildNow.toISOString(),
-      node_count: nodeCount,
-      edge_count: actualEdgeCount,
-    });
-  } catch (err) {
-    warn(`Failed to write build metadata: ${(err as Error).message}`);
+  // For small incremental builds, skip persisting build metadata — the
+  // engine/version/schema haven't changed (would have triggered a full rebuild),
+  // built_at is only used by stale-embeddings check (skipped for incremental),
+  // and counts are only used by drift detection (skipped for ≤3 files).
+  // This avoids a transaction commit + WAL fsync (~15-30ms).
+  // Threshold aligned with drift detection gate (allSymbols.size > 3) so stored
+  // counts stay fresh whenever drift detection reads them.
+  if (isFullBuild || allSymbols.size > 3) {
+    try {
+      if (ctx.nativeDb) {
+        ctx.nativeDb.setBuildMeta(
+          Object.entries({
+            engine: ctx.engineName,
+            engine_version: ctx.engineVersion || '',
+            codegraph_version: CODEGRAPH_VERSION,
+            schema_version: String(schemaVersion),
+            built_at: buildNow.toISOString(),
+            node_count: String(nodeCount),
+            edge_count: String(actualEdgeCount),
+          }).map(([key, value]) => ({ key, value: String(value) })),
+        );
+      } else {
+        setBuildMeta(db, {
+          engine: ctx.engineName,
+          engine_version: ctx.engineVersion || '',
+          codegraph_version: CODEGRAPH_VERSION,
+          schema_version: String(schemaVersion),
+          built_at: buildNow.toISOString(),
+          node_count: nodeCount,
+          edge_count: actualEdgeCount,
+        });
+      }
+    } catch (err) {
+      warn(`Failed to write build metadata: ${(err as Error).message}`);
+    }
   }
 
-  // Orphaned embeddings warning
-  if (hasEmbeddings) {
+  // Skip expensive advisory queries for incremental builds — these are
+  // informational warnings that don't affect correctness and cost ~40-60ms.
+  if (!isFullBuild) {
+    debug(
+      'Finalize: skipping advisory queries (orphaned/stale embeddings, unused exports) for incremental build',
+    );
+  } else {
+    // Orphaned embeddings warning
+    if (hasEmbeddings) {
+      try {
+        const orphaned = (
+          db
+            .prepare(
+              'SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)',
+            )
+            .get() as { c: number }
+        ).c;
+        if (orphaned > 0) {
+          warn(
+            `${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
+          );
+        }
+      } catch {
+        /* ignore - embeddings table may have been dropped */
+      }
+    }
+
+    // Stale embeddings warning (built before current graph rebuild)
+    if (hasEmbeddings) {
+      try {
+        const embedBuiltAt = (
+          db.prepare("SELECT value FROM embedding_meta WHERE key = 'built_at'").get() as
+            | { value: string }
+            | undefined
+        )?.value;
+        if (embedBuiltAt) {
+          const embedTime = new Date(embedBuiltAt).getTime();
+          if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
+            warn(
+              'Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.',
+            );
+          }
+        }
+      } catch {
+        /* ignore - embedding_meta table may not exist */
+      }
+    }
+
+    // Unused exports warning
     try {
-      const orphaned = (
+      const unusedCount = (
         db
           .prepare(
-            'SELECT COUNT(*) as c FROM embeddings WHERE node_id NOT IN (SELECT id FROM nodes)',
+            `SELECT COUNT(*) as c FROM nodes
+         WHERE exported = 1 AND kind != 'file'
+           AND id NOT IN (
+             SELECT DISTINCT e.target_id FROM edges e
+             JOIN nodes caller ON e.source_id = caller.id
+             JOIN nodes target ON e.target_id = target.id
+             WHERE e.kind = 'calls' AND caller.file != target.file
+           )`,
           )
           .get() as { c: number }
       ).c;
-      if (orphaned > 0) {
+      if (unusedCount > 0) {
         warn(
-          `${orphaned} embeddings are orphaned (nodes changed). Run "codegraph embed" to refresh.`,
+          `${unusedCount} exported symbol${unusedCount > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
         );
       }
     } catch {
-      /* ignore - embeddings table may have been dropped */
+      /* exported column may not exist on older DBs */
     }
   }
 
-  // Stale embeddings warning (built before current graph rebuild)
-  if (hasEmbeddings) {
-    try {
-      const embedBuiltAt = (
-        db.prepare("SELECT value FROM embedding_meta WHERE key = 'built_at'").get() as
-          | { value: string }
-          | undefined
-      )?.value;
-      if (embedBuiltAt) {
-        const embedTime = new Date(embedBuiltAt).getTime();
-        if (!Number.isNaN(embedTime) && embedTime < buildNow.getTime()) {
-          warn(
-            'Embeddings were built before the last graph rebuild. Run "codegraph embed" to update.',
-          );
-        }
-      }
-    } catch {
-      /* ignore - embedding_meta table may not exist */
-    }
-  }
+  // Intentionally measured before closeDb / writeJournalHeader / auto-registration:
+  // for the deferred-close path the close is async (setImmediate), and for full
+  // builds the metric captures finalize logic only — DB close cost is tracked
+  // separately via timing.closeDbMs when available.
+  ctx.timing.finalizeMs = performance.now() - t0;
 
-  // Unused exports warning
-  try {
-    const unusedCount = (
-      db
-        .prepare(
-          `SELECT COUNT(*) as c FROM nodes
-       WHERE exported = 1 AND kind != 'file'
-         AND id NOT IN (
-           SELECT DISTINCT e.target_id FROM edges e
-           JOIN nodes caller ON e.source_id = caller.id
-           JOIN nodes target ON e.target_id = target.id
-           WHERE e.kind = 'calls' AND caller.file != target.file
-         )`,
-        )
-        .get() as { c: number }
-    ).c;
-    if (unusedCount > 0) {
-      warn(
-        `${unusedCount} exported symbol${unusedCount > 1 ? 's have' : ' has'} zero cross-file consumers. Run "codegraph exports <file> --unused" to inspect.`,
-      );
-    }
-  } catch {
-    /* exported column may not exist on older DBs */
+  // Close NativeDatabase (fast, ~1ms) then better-sqlite3 (WAL checkpoint).
+  // For small incremental builds, defer the expensive WAL checkpoint to the
+  // next event loop tick. Skip for temp directories (tests) — they rmSync
+  // immediately after build.
+  const pair = { db, nativeDb: ctx.nativeDb };
+  const isTempDir = path.resolve(rootDir).startsWith(path.resolve(tmpdir()));
+  if (!isFullBuild && allSymbols.size <= 5 && !isTempDir) {
+    closeDbPairDeferred(pair);
+  } else {
+    closeDbPair(pair);
   }
 
-  closeDb(db);
-
   // Write journal header after successful build
   writeJournalHeader(rootDir, Date.now());
 
-  // Auto-registration
-  if (!opts.skipRegistry) {
-    const { tmpdir } = await import('node:os');
+  // Skip auto-registration for incremental builds — the repo was already
+  // registered during the initial full build. The dynamic import + file I/O
+  // costs ~100ms which dominates incremental finalize time.
+  if (!opts.skipRegistry && isFullBuild) {
     const tmpDir = path.resolve(tmpdir());
     const resolvedRoot = path.resolve(rootDir);
     if (resolvedRoot.startsWith(tmpDir)) {
@@ -172,6 +222,4 @@ export async function finalize(ctx: PipelineContext): Promise<void> {
       }
     }
   }
-
-  ctx.timing.finalizeMs = performance.now() - t0;
 }

package/src/domain/graph/builder/stages/insert-nodes.ts

@@ -3,12 +3,20 @@
  *
  * Batch-inserts file nodes, definitions, exports, children, and contains/parameter_of edges.
  * Updates file hashes for incremental builds.
+ *
+ * When the native engine is available, delegates all SQLite writes to Rust via
+ * `bulkInsertNodes` — eliminating JS↔C boundary overhead. Falls back to the
+ * JS implementation on failure or when native is unavailable.
  */
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
-import type BetterSqlite3 from 'better-sqlite3';
 import { bulkNodeIdsByFile } from '../../../../db/index.js';
-import type { ExtractorOutput, MetadataUpdate } from '../../../../types.js';
+import type {
+  BetterSqlite3Database,
+  ExtractorOutput,
+  MetadataUpdate,
+  SqliteStatement,
+} from '../../../../types.js';
 import type { PipelineContext } from '../context.js';
 import {
   batchInsertEdges,
@@ -28,10 +36,115 @@ interface PrecomputedFileData {
   _reverseDepOnly?: boolean;
 }
 
-// ── Phase 1: Insert file nodes, definitions, exports ────────────────────
+// ── Native fast-path ─────────────────────────────────────────────────
+
+function tryNativeInsert(ctx: PipelineContext): boolean {
+  // Use NativeDatabase persistent connection (Phase 6.15+).
+  // Standalone napi functions were removed in 6.17 — falls through to JS if nativeDb unavailable.
+  if (!ctx.nativeDb?.bulkInsertNodes) return false;
+
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  // Marshal allSymbols → InsertNodesBatch[]
+  const batches: Array<{
+    file: string;
+    definitions: Array<{
+      name: string;
+      kind: string;
+      line: number;
+      endLine?: number | null;
+      visibility?: string | null;
+      children: Array<{
+        name: string;
+        kind: string;
+        line: number;
+        endLine?: number | null;
+        visibility?: string | null;
+      }>;
+    }>;
+    exports: Array<{ name: string; kind: string; line: number }>;
+  }> = [];
+
+  for (const [relPath, symbols] of allSymbols) {
+    batches.push({
+      file: relPath,
+      definitions: symbols.definitions.map((def) => ({
+        name: def.name,
+        kind: def.kind,
+        line: def.line,
+        endLine: def.endLine ?? null,
+        visibility: def.visibility ?? null,
+        children: (def.children ?? []).map((c) => ({
+          name: c.name,
+          kind: c.kind,
+          line: c.line,
+          endLine: c.endLine ?? null,
+          visibility: c.visibility ?? null,
+        })),
+      })),
+      exports: symbols.exports.map((exp) => ({
+        name: exp.name,
+        kind: exp.kind,
+        line: exp.line,
+      })),
+    });
+  }
+
+  // Build file hash entries
+  const precomputedData = new Map<string, PrecomputedFileData>();
+  for (const item of filesToParse) {
+    if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
+  }
+
+  const fileHashes: Array<{ file: string; hash: string; mtime: number; size: number }> = [];
+  for (const [relPath] of allSymbols) {
+    const precomputed = precomputedData.get(relPath);
+    if (precomputed?._reverseDepOnly) {
+      continue; // file unchanged, hash already correct
+    }
+    if (precomputed?.hash) {
+      let mtime: number;
+      let size: number;
+      if (precomputed.stat) {
+        mtime = precomputed.stat.mtime;
+        size = precomputed.stat.size;
+      } else {
+        const rawStat = fileStat(path.join(rootDir, relPath));
+        mtime = rawStat ? Math.floor(rawStat.mtimeMs) : 0;
+        size = rawStat ? rawStat.size : 0;
+      }
+      fileHashes.push({ file: relPath, hash: precomputed.hash, mtime, size });
+    } else {
+      const absPath = path.join(rootDir, relPath);
+      let code: string | null;
+      try {
+        code = readFileSafe(absPath);
+      } catch {
+        code = null;
+      }
+      if (code !== null) {
+        const stat = fileStat(absPath);
+        const mtime = stat ? Math.floor(stat.mtimeMs) : 0;
+        const size = stat ? stat.size : 0;
+        fileHashes.push({ file: relPath, hash: fileHash(code), mtime, size });
+      }
+    }
+  }
+
+  // Also include metadata-only updates (self-heal mtime/size without re-parse)
+  for (const item of metadataUpdates) {
+    const mtime = item.stat ? Math.floor(item.stat.mtime) : 0;
+    const size = item.stat ? item.stat.size : 0;
+    fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
+  }
+
+  return ctx.nativeDb.bulkInsertNodes(batches, fileHashes, removed);
+}
+
+// ── JS fallback: Phase 1 ────────────────────────────────────────────
 
 function insertDefinitionsAndExports(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   allSymbols: Map<string, ExtractorOutput>,
 ): void {
   const phase1Rows: unknown[][] = [];
@@ -63,7 +176,7 @@ function insertDefinitionsAndExports(
   // Mark exported symbols in batches (cache prepared statements by chunk size)
   if (exportKeys.length > 0) {
     const EXPORT_CHUNK = 500;
-    const exportStmtCache = new Map<number, BetterSqlite3.Statement>();
+    const exportStmtCache = new Map<number, SqliteStatement>();
     for (let i = 0; i < exportKeys.length; i += EXPORT_CHUNK) {
       const end = Math.min(i + EXPORT_CHUNK, exportKeys.length);
       const chunkSize = end - i;
@@ -86,10 +199,10 @@ function insertDefinitionsAndExports(
   }
 }
 
-// ── Phase 2+3: Insert children and containment edges (two nodeIdMap passes) ──
+// ── JS fallback: Phase 2+3 ──────────────────────────────────────────
 
 function insertChildrenAndEdges(
-  db: BetterSqlite3.Database,
+  db: BetterSqlite3Database,
   allSymbols: Map<string, ExtractorOutput>,
 ): void {
   const childRows: unknown[][] = [];
@@ -161,15 +274,15 @@ function insertChildrenAndEdges(
   batchInsertEdges(db, edgeRows);
 }
 
-// ── Phase 4: Update file hashes ─────────────────────────────────────────
+// ── JS fallback: Phase 4 ────────────────────────────────────────────
 
 function updateFileHashes(
-  _db: BetterSqlite3.Database,
+  _db: BetterSqlite3Database,
   allSymbols: Map<string, ExtractorOutput>,
   precomputedData: Map<string, PrecomputedFileData>,
   metadataUpdates: MetadataUpdate[],
   rootDir: string,
-  upsertHash: BetterSqlite3.Statement | null,
+  upsertHash: SqliteStatement | null,
 ): void {
   if (!upsertHash) return;
 
@@ -214,17 +327,33 @@ function updateFileHashes(
   }
 }
 
-// ── Main entry point ────────────────────────────────────────────────────
+// ── Main entry point ────────────────────────────────────────────────
 
 export async function insertNodes(ctx: PipelineContext): Promise<void> {
   const { db, allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
 
+  // Populate fileSymbols before any DB writes (used by later stages)
+  for (const [relPath, symbols] of allSymbols) {
+    ctx.fileSymbols.set(relPath, symbols);
+  }
+
+  const t0 = performance.now();
+
+  // Try native Rust path first — single transaction, no JS↔C overhead
+  if (ctx.engineName === 'native' && tryNativeInsert(ctx)) {
+    ctx.timing.insertMs = performance.now() - t0;
+
+    // Removed-file hash cleanup is handled inside the native call
+    return;
+  }
+
+  // JS fallback
   const precomputedData = new Map<string, PrecomputedFileData>();
   for (const item of filesToParse) {
     if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
   }
 
-  let upsertHash: BetterSqlite3.Statement | null;
+  let upsertHash: SqliteStatement | null;
   try {
     upsertHash = db.prepare(
       'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
@@ -233,18 +362,12 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
     upsertHash = null;
   }
 
-  // Populate fileSymbols before the transaction so it is a pure input
-  for (const [relPath, symbols] of allSymbols) {
-    ctx.fileSymbols.set(relPath, symbols);
-  }
-
   const insertAll = db.transaction(() => {
     insertDefinitionsAndExports(db, allSymbols);
     insertChildrenAndEdges(db, allSymbols);
     updateFileHashes(db, allSymbols, precomputedData, metadataUpdates, rootDir, upsertHash);
   });
 
-  const t0 = performance.now();
   insertAll();
   ctx.timing.insertMs = performance.now() - t0;
 

package/src/domain/graph/builder/stages/resolve-imports.ts

@@ -41,18 +41,83 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
 
   ctx.barrelOnlyFiles = new Set<string>();
   if (!isFullBuild) {
-    const barrelCandidates = db
-      .prepare(`SELECT DISTINCT n1.file FROM edges e
+    // Collect the set of changed file paths to scope barrel re-parsing.
+    const changedRelPaths = new Set<string>(fileSymbols.keys());
+
+    // For small incremental builds (≤5 files), only re-parse barrel files
+    // that are related to the changed files — either re-exporting from them
+    // or imported by them. For larger changes, re-parse all barrels.
+    let barrelCandidates: Array<{ file: string }>;
+    if (changedRelPaths.size <= 5) {
+      // All known barrel files (has at least one reexport edge)
+      const allBarrelFiles = new Set(
+        (
+          db
+            .prepare(
+              `SELECT DISTINCT n1.file FROM edges e
+               JOIN nodes n1 ON e.source_id = n1.id
+               WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+            )
+            .all() as Array<{ file: string }>
+        ).map((r) => r.file),
+      );
+
+      const barrels = new Set<string>();
+
+      // Find barrels imported by changed files using parsed import data
+      // (can't query DB edges — they were purged for the changed files).
+      for (const relPath of changedRelPaths) {
+        const symbols = fileSymbols.get(relPath);
+        if (!symbols) continue;
+        for (const imp of symbols.imports) {
+          const resolved = ctx.batchResolved?.get(`${path.join(rootDir, relPath)}|${imp.source}`);
+          const target =
+            resolved ??
+            resolveImportPath(path.join(rootDir, relPath), imp.source, rootDir, aliases);
+          if (allBarrelFiles.has(target)) barrels.add(target);
+        }
+      }
+
+      // Also find barrels that re-export from the changed files
+      const reexportSourceStmt = db.prepare(
+        `SELECT DISTINCT n1.file FROM edges e
          JOIN nodes n1 ON e.source_id = n1.id
-         WHERE e.kind = 'reexports' AND n1.kind = 'file'`)
-      .all() as Array<{ file: string }>;
+         JOIN nodes n2 ON e.target_id = n2.id
+         WHERE e.kind = 'reexports' AND n1.kind = 'file' AND n2.file = ?`,
+      );
+      for (const relPath of changedRelPaths) {
+        for (const row of reexportSourceStmt.all(relPath) as Array<{ file: string }>) {
+          barrels.add(row.file);
+        }
+      }
+      barrelCandidates = [...barrels].map((file) => ({ file }));
+    } else {
+      barrelCandidates = db
+        .prepare(
+          `SELECT DISTINCT n1.file FROM edges e
+           JOIN nodes n1 ON e.source_id = n1.id
+           WHERE e.kind = 'reexports' AND n1.kind = 'file'`,
+        )
+        .all() as Array<{ file: string }>;
+    }
+
+    // Batch-parse all barrel candidates at once instead of one-by-one
+    const barrelPaths: string[] = [];
     for (const { file: relPath } of barrelCandidates) {
-      if (fileSymbols.has(relPath)) continue;
-      const absPath = path.join(rootDir, relPath);
+      if (!fileSymbols.has(relPath)) {
+        barrelPaths.push(path.join(rootDir, relPath));
+      }
+    }
+
+    if (barrelPaths.length > 0) {
+      const deleteOutgoingEdges = db.prepare(
+        'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+      );
+
       try {
-        const symbols = await parseFilesAuto([absPath], rootDir, engineOpts);
-        const fileSym = symbols.get(relPath);
-        if (fileSym) {
+        const barrelSymbols = await parseFilesAuto(barrelPaths, rootDir, engineOpts);
+        for (const [relPath, fileSym] of barrelSymbols) {
+          deleteOutgoingEdges.run(relPath);
           fileSymbols.set(relPath, fileSym);
           ctx.barrelOnlyFiles.add(relPath);
           const reexports = fileSym.imports.filter((imp: Import) => imp.reexport);
@@ -60,7 +125,7 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
             ctx.reexportMap.set(
               relPath,
               reexports.map((imp: Import) => ({
-                source: getResolved(ctx, absPath, imp.source),
+                source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
                 names: imp.names,
                 wildcardReexport: imp.wildcardReexport || false,
               })),

package/src/domain/graph/cycles.ts

@@ -16,9 +16,9 @@ export function findCycles(
   const idToLabel = new Map<string, string>();
   for (const [id, attrs] of graph.nodes()) {
     if (fileLevel) {
-      idToLabel.set(id, attrs['file'] as string);
+      idToLabel.set(id, attrs.file as string);
     } else {
-      idToLabel.set(id, `${attrs['label']}|${attrs['file']}`);
+      idToLabel.set(id, `${attrs.label}|${attrs.file}`);
     }
   }