@optave/codegraph 3.8.0 → 3.9.0

package/src/domain/graph/builder/stages/build-edges.ts

@@ -197,8 +197,13 @@ function buildImportEdgesNative(
   };
   const fileNodeRowCache = new Map<string, { id: number }>();
 
-  // 2. Pre-resolve all imports and collect supplemental resolved entries
-  const supplementalResolved: Array<{ key: string; resolvedPath: string }> = [];
+  // 2. Pre-resolve all imports and build resolved imports array.
+  // Keys use forward-slash-normalized rootDir + "/" + relPath to match the Rust
+  // lookup format (format!("{}/{}", root_dir.replace('\\', "/"), file)).
+  // On Windows, rootDir has backslashes but Rust normalizes them — the JS side
+  // must do the same or every resolve key lookup misses (#750).
+  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
+  const fwdRootDir = rootDir.replace(/\\/g, '/');
 
   for (const [relPath, symbols] of fileSymbols) {
     const fileNodeRow = addFileNodeId(relPath);
@@ -218,11 +223,8 @@ function buildImportEdgesNative(
       const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
       addFileNodeId(resolvedPath);
 
-      // Check if this resolution is in batchResolved; if not, add supplemental
-      const resolveKey = `${path.join(rootDir, relPath)}|${imp.source}`;
-      if (!ctx.batchResolved?.has(resolveKey)) {
-        supplementalResolved.push({ key: resolveKey, resolvedPath });
-      }
+      // Key matches Rust's format!("{}/{}", root_dir.replace('\\', "/"), file_input.file)
+      resolvedImports.push({ key: `${fwdRootDir}/${relPath}|${imp.source}`, resolvedPath });
 
       importInfos.push({
         source: imp.source,
@@ -243,17 +245,6 @@ function buildImportEdgesNative(
     });
   }
 
-  // 3. Flatten batchResolved + supplemental into resolved imports array
-  const resolvedImports: Array<{ key: string; resolvedPath: string }> = [];
-  if (ctx.batchResolved) {
-    for (const [key, resolvedPath] of ctx.batchResolved) {
-      resolvedImports.push({ key, resolvedPath });
-    }
-  }
-  for (const entry of supplementalResolved) {
-    resolvedImports.push(entry);
-  }
-
   // 4. Flatten reexportMap
   const fileReexports: Array<{
     file: string;
@@ -363,7 +354,10 @@ function buildImportedNamesForNative(
   rootDir: string,
 ): Array<{ name: string; file: string }> {
   const importedNames: Array<{ name: string; file: string }> = [];
-  for (const imp of symbols.imports) {
+  // Process dynamic imports first (lower priority), then static imports
+  // (higher priority). Rust HashMap::collect keeps the last entry per key,
+  // so static imports win when both contribute the same name.
+  const addImports = (imp: (typeof symbols.imports)[number]) => {
     const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
     for (const name of imp.names) {
       const cleanName = name.replace(/^\*\s+as\s+/, '');
@@ -374,6 +368,12 @@ function buildImportedNamesForNative(
       }
       importedNames.push({ name: cleanName, file: targetFile });
     }
+  };
+  for (const imp of symbols.imports) {
+    if (imp.dynamicImport) addImports(imp);
+  }
+  for (const imp of symbols.imports) {
+    if (!imp.dynamicImport) addImports(imp);
   }
   return importedNames;
 }
@@ -418,12 +418,25 @@ function buildImportedNamesMap(
   rootDir: string,
 ): Map<string, string> {
   const importedNames = new Map<string, string>();
+  // Process dynamic imports first (lower priority), then static imports
+  // (higher priority). Static imports represent direct bindings while dynamic
+  // imports often use aliased destructuring (`{ foo: bar } = await import(…)`).
+  // When both contribute the same name, the static binding is authoritative.
   for (const imp of symbols.imports) {
+    if (!imp.dynamicImport) continue;
     const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
     for (const name of imp.names) {
       importedNames.set(name.replace(/^\*\s+as\s+/, ''), resolvedPath);
     }
   }
+  for (const imp of symbols.imports) {
+    if (imp.dynamicImport) continue;
+    const resolvedPath = getResolved(ctx, path.join(rootDir, relPath), imp.source);
+    for (const name of imp.names) {
+      const cleanName = name.replace(/^\*\s+as\s+/, '');
+      importedNames.set(cleanName, resolvedPath);
+    }
+  }
   return importedNames;
 }
 
@@ -748,7 +761,20 @@ export async function buildEdges(ctx: PipelineContext): Promise<void> {
     const useNativeImportEdges =
       native?.buildImportEdges && (ctx.isFullBuild || ctx.fileSymbols.size > 3);
     if (useNativeImportEdges) {
+      const beforeLen = allEdgeRows.length;
       buildImportEdgesNative(ctx, getNodeIdStmt, allEdgeRows, native!);
+      // Fallback: if native produced 0 import edges but there are imports to
+      // process, the native binary may have a key-format mismatch (e.g. Windows
+      // path separators — #750).  Retry with the JS implementation.
+      // NOTE: This also fires for codebases where every import targets an
+      // external package (npm deps) that the resolver intentionally skips.
+      // In that case the JS path resolves zero edges too, so the only cost
+      // is the redundant JS traversal — no correctness impact.
+      const hasImports = [...ctx.fileSymbols.values()].some((s) => s.imports.length > 0);
+      if (allEdgeRows.length === beforeLen && hasImports) {
+        debug('Native buildImportEdges produced 0 edges — falling back to JS');
+        buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
+      }
     } else {
       buildImportEdges(ctx, getNodeIdStmt, allEdgeRows);
     }

package/src/domain/graph/builder/stages/detect-changes.ts

@@ -349,7 +349,7 @@ function findReverseDependencies(
     const changedArray = [...changedRelPaths];
     const nativeResults = nativeDb.findReverseDependencies(changedArray);
     for (const dep of nativeResults) {
-      const absPath = path.join(rootDir, dep);
+      const absPath = path.isAbsolute(dep) ? dep : path.join(rootDir, dep);
       if (fs.existsSync(absPath)) {
         reverseDeps.add(dep);
       }
@@ -366,7 +366,7 @@ function findReverseDependencies(
   for (const relPath of changedRelPaths) {
     for (const row of findReverseDepsStmt.all(relPath) as Array<{ file: string }>) {
       if (!changedRelPaths.has(row.file) && !reverseDeps.has(row.file)) {
-        const absPath = path.join(rootDir, row.file);
+        const absPath = path.isAbsolute(row.file) ? row.file : path.join(rootDir, row.file);
         if (fs.existsSync(absPath)) {
           reverseDeps.add(row.file);
         }

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

@@ -86,7 +86,7 @@ function persistBuildMetadata(
       ctx.nativeDb!.setBuildMeta(
         Object.entries({
           engine: ctx.engineName,
-          engine_version: ctx.engineVersion || '',
+          engine_version: CODEGRAPH_VERSION,
           codegraph_version: CODEGRAPH_VERSION,
           schema_version: String(ctx.schemaVersion),
           built_at: buildNow.toISOString(),
@@ -97,7 +97,7 @@ function persistBuildMetadata(
     } else {
       setBuildMeta(ctx.db, {
         engine: ctx.engineName,
-        engine_version: ctx.engineVersion || '',
+        engine_version: CODEGRAPH_VERSION,
         codegraph_version: CODEGRAPH_VERSION,
         schema_version: String(ctx.schemaVersion),
         built_at: buildNow.toISOString(),

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

@@ -11,6 +11,8 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { bulkNodeIdsByFile } from '../../../../db/index.js';
+import { debug } from '../../../../infrastructure/logger.js';
+import { toErrorMessage } from '../../../../shared/errors.js';
 import type {
   BetterSqlite3Database,
   ExtractorOutput,
@@ -36,35 +38,31 @@ interface PrecomputedFileData {
   _reverseDepOnly?: boolean;
 }
 
-// ── Native fast-path ─────────────────────────────────────────────────
+// ── Native fast-path helpers ─────────────────────────────────────────
 
-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<{
+/** Shape of a marshaled batch for native bulk insert. */
+interface InsertNodesBatch {
+  file: string;
+  definitions: Array<{
+    name: string;
+    kind: string;
+    line: number;
+    endLine?: number;
+    visibility?: string;
+    children: Array<{
       name: string;
       kind: string;
       line: number;
       endLine?: number;
       visibility?: string;
-      children: Array<{
-        name: string;
-        kind: string;
-        line: number;
-        endLine?: number;
-        visibility?: string;
-      }>;
     }>;
-    exports: Array<{ name: string; kind: string; line: number }>;
-  }> = [];
+  }>;
+  exports: Array<{ name: string; kind: string; line: number }>;
+}
 
+/** Marshal allSymbols into the batch format expected by native bulkInsertNodes. */
+function marshalSymbolBatches(allSymbols: Map<string, ExtractorOutput>): InsertNodesBatch[] {
+  const batches: InsertNodesBatch[] = [];
   for (const [relPath, symbols] of allSymbols) {
     batches.push({
       file: relPath,
@@ -89,14 +87,18 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
       })),
     });
   }
+  return batches;
+}
 
-  // 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);
-  }
-
+/** Build file hash entries from parsed symbols and precomputed/metadata sources. */
+function buildFileHashes(
+  allSymbols: Map<string, ExtractorOutput>,
+  precomputedData: Map<string, PrecomputedFileData>,
+  metadataUpdates: MetadataUpdate[],
+  rootDir: string,
+): Array<{ file: string; hash: string; mtime: number; size: number }> {
   const fileHashes: Array<{ file: string; hash: string; mtime: number; size: number }> = [];
+
   for (const [relPath] of allSymbols) {
     const precomputed = precomputedData.get(relPath);
     if (precomputed?._reverseDepOnly) {
@@ -119,7 +121,8 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
       let code: string | null;
       try {
         code = readFileSafe(absPath);
-      } catch {
+      } catch (e) {
+        debug(`buildFileHashes: readFileSafe failed for ${relPath}: ${toErrorMessage(e)}`);
         code = null;
       }
       if (code !== null) {
@@ -138,6 +141,24 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
     fileHashes.push({ file: item.relPath, hash: item.hash, mtime, size });
   }
 
+  return fileHashes;
+}
+
+// ── Native fast-path ─────────────────────────────────────────────────
+
+function tryNativeInsert(ctx: PipelineContext): boolean {
+  if (!ctx.nativeDb?.bulkInsertNodes) return false;
+
+  const { allSymbols, filesToParse, metadataUpdates, rootDir, removed } = ctx;
+
+  const batches = marshalSymbolBatches(allSymbols);
+
+  const precomputedData = new Map<string, PrecomputedFileData>();
+  for (const item of filesToParse) {
+    if (item.relPath) precomputedData.set(item.relPath, item as PrecomputedFileData);
+  }
+  const fileHashes = buildFileHashes(allSymbols, precomputedData, metadataUpdates, rootDir);
+
   // WAL guard: same suspendJsDb/resumeJsDb pattern used by feature modules
   // (ast, cfg, complexity, dataflow). Checkpoint JS side before native write,
   // then checkpoint native side after, so neither library reads WAL frames
@@ -151,8 +172,10 @@ function tryNativeInsert(ctx: PipelineContext): boolean {
   } finally {
     try {
       ctx.nativeDb?.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch {
-      /* ignore — nativeDb may already be closed */
+    } catch (e) {
+      debug(
+        `tryNativeInsert: WAL checkpoint failed (nativeDb may already be closed): ${toErrorMessage(e)}`,
+      );
     }
   }
   return result;
@@ -324,7 +347,8 @@ function updateFileHashes(
       let code: string | null;
       try {
         code = readFileSafe(absPath);
-      } catch {
+      } catch (e) {
+        debug(`updateFileHashes: readFileSafe failed for ${relPath}: ${toErrorMessage(e)}`);
         code = null;
       }
       if (code !== null) {
@@ -364,8 +388,8 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
         // Removed-file hash cleanup is handled inside the native call
         return;
       }
-    } catch {
-      // Native insert failed — fall through to JS implementation
+    } catch (e) {
+      debug(`insertNodes: native insert failed, falling back to JS: ${toErrorMessage(e)}`);
     }
   }
 
@@ -380,7 +404,8 @@ export async function insertNodes(ctx: PipelineContext): Promise<void> {
     upsertHash = ctx.db.prepare(
       'INSERT OR REPLACE INTO file_hashes (file, hash, mtime, size) VALUES (?, ?, ?, ?)',
     );
-  } catch {
+  } catch (e) {
+    debug(`insertNodes: file_hashes prepare failed (table may not exist): ${toErrorMessage(e)}`);
     upsertHash = null;
   }
 

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

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import { performance } from 'node:perf_hooks';
 import { debug } from '../../../../infrastructure/logger.js';
+import { normalizePath } from '../../../../shared/constants.js';
 import type { Import } from '../../../../types.js';
 import { parseFilesAuto } from '../../../parser.js';
 import { resolveImportPath, resolveImportsBatch } from '../../resolve.js';
@@ -12,20 +13,10 @@ interface ReexportEntry {
   wildcardReexport: boolean;
 }
 
-export async function resolveImports(ctx: PipelineContext): Promise<void> {
-  const { db, fileSymbols, rootDir, aliases, allFiles, isFullBuild, engineOpts } = ctx;
-  const t0 = performance.now();
-  const batchInputs: Array<{ fromFile: string; importSource: string }> = [];
-  for (const [relPath, symbols] of fileSymbols) {
-    const absFile = path.join(rootDir, relPath);
-    for (const imp of symbols.imports) {
-      batchInputs.push({ fromFile: absFile, importSource: imp.source });
-    }
-  }
-  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
-  ctx.timing.resolveMs = performance.now() - t0;
-
+/** Collect reexport entries from fileSymbols into the reexportMap. */
+function buildReexportMap(ctx: PipelineContext): void {
   ctx.reexportMap = new Map<string, ReexportEntry[]>();
+  const { fileSymbols, rootDir } = ctx;
   for (const [relPath, symbols] of fileSymbols) {
     const reexports = symbols.imports.filter((imp) => imp.reexport);
     if (reexports.length > 0) {
@@ -39,110 +30,141 @@ export async function resolveImports(ctx: PipelineContext): Promise<void> {
       );
     }
   }
+}
 
-  ctx.barrelOnlyFiles = new Set<string>();
-  if (!isFullBuild) {
-    // 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),
-      );
+/**
+ * Find barrel files related to changed files for scoped re-parsing.
+ * For small incremental builds (<=5 files), only barrels that re-export from
+ * or are imported by the changed files. For larger changes, all barrels.
+ */
+function findBarrelCandidates(ctx: PipelineContext): Array<{ file: string }> {
+  const { db, fileSymbols, rootDir, aliases } = ctx;
+  const changedRelPaths = new Set<string>(fileSymbols.keys());
 
-      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);
-        }
-      }
+  const SMALL_CHANGE_THRESHOLD = 5;
+  if (changedRelPaths.size <= SMALL_CHANGE_THRESHOLD) {
+    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),
+    );
 
-      // 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
-         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);
-        }
+    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(
+          `${normalizePath(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);
       }
-      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)) {
-        barrelPaths.push(path.join(rootDir, relPath));
+    // 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
+       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);
       }
     }
+    return [...barrels].map((file) => ({ file }));
+  }
 
-    if (barrelPaths.length > 0) {
-      const deleteOutgoingEdges = db.prepare(
-        'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
-      );
+  return 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 }>;
+}
 
-      try {
-        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);
-          if (reexports.length > 0) {
-            ctx.reexportMap.set(
-              relPath,
-              reexports.map((imp: Import) => ({
-                source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
-                names: imp.names,
-                wildcardReexport: imp.wildcardReexport || false,
-              })),
-            );
-          }
-        }
-      } catch (e: unknown) {
-        debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
+/** Re-parse barrel files and update fileSymbols/reexportMap with fresh data. */
+async function reparseBarrelFiles(
+  ctx: PipelineContext,
+  barrelCandidates: Array<{ file: string }>,
+): Promise<void> {
+  const { db, fileSymbols, rootDir, engineOpts } = ctx;
+
+  const barrelPaths: string[] = [];
+  for (const { file: relPath } of barrelCandidates) {
+    if (!fileSymbols.has(relPath)) {
+      barrelPaths.push(path.join(rootDir, relPath));
+    }
+  }
+
+  if (barrelPaths.length === 0) return;
+
+  const deleteOutgoingEdges = db.prepare(
+    'DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE file = ?)',
+  );
+
+  try {
+    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);
+      if (reexports.length > 0) {
+        ctx.reexportMap.set(
+          relPath,
+          reexports.map((imp: Import) => ({
+            source: getResolved(ctx, path.join(rootDir, relPath), imp.source),
+            names: imp.names,
+            wildcardReexport: imp.wildcardReexport || false,
+          })),
+        );
       }
     }
+  } catch (e: unknown) {
+    debug(`Barrel re-parse failed (non-fatal): ${(e as Error).message}`);
+  }
+}
+
+export async function resolveImports(ctx: PipelineContext): Promise<void> {
+  const { fileSymbols, rootDir, aliases, allFiles, isFullBuild } = ctx;
+  const t0 = performance.now();
+
+  const batchInputs: Array<{ fromFile: string; importSource: string }> = [];
+  for (const [relPath, symbols] of fileSymbols) {
+    const absFile = path.join(rootDir, relPath);
+    for (const imp of symbols.imports) {
+      batchInputs.push({ fromFile: absFile, importSource: imp.source });
+    }
+  }
+  ctx.batchResolved = resolveImportsBatch(batchInputs, rootDir, aliases, allFiles);
+  ctx.timing.resolveMs = performance.now() - t0;
+
+  buildReexportMap(ctx);
+
+  ctx.barrelOnlyFiles = new Set<string>();
+  if (!isFullBuild) {
+    const barrelCandidates = findBarrelCandidates(ctx);
+    await reparseBarrelFiles(ctx, barrelCandidates);
   }
 }
 
 export function getResolved(ctx: PipelineContext, absFile: string, importSource: string): string {
   if (ctx.batchResolved) {
-    const key = `${absFile}|${importSource}`;
+    const key = `${normalizePath(absFile)}|${importSource}`;
     const hit = ctx.batchResolved.get(key);
     if (hit !== undefined) return hit;
   }