@optave/codegraph 3.3.0 → 3.4.0

package/src/domain/graph/{change-journal.js → change-journal.ts}

@@ -5,36 +5,36 @@ import { debug, warn } from '../../infrastructure/logger.js';
 export const CHANGE_EVENTS_FILENAME = 'change-events.ndjson';
 export const DEFAULT_MAX_BYTES = 1024 * 1024; // 1 MB
 
-/**
- * Returns the absolute path to the NDJSON change events file.
- */
-export function changeEventsPath(rootDir) {
+export function changeEventsPath(rootDir: string): string {
   return path.join(rootDir, '.codegraph', CHANGE_EVENTS_FILENAME);
 }
 
-/**
- * Compare old and new symbol arrays, returning added/removed/modified sets.
- * Symbols are keyed on `name\0kind`. A symbol is "modified" if the same
- * name+kind exists in both but the line changed.
- *
- * @param {Array<{name:string, kind:string, line:number}>} oldSymbols
- * @param {Array<{name:string, kind:string, line:number}>} newSymbols
- * @returns {{ added: Array, removed: Array, modified: Array }}
- */
-export function diffSymbols(oldSymbols, newSymbols) {
-  const oldMap = new Map();
+interface SymbolEntry {
+  name: string;
+  kind: string;
+  line: number;
+}
+
+interface SymbolDiff {
+  added: Array<{ name: string; kind: string; line: number }>;
+  removed: Array<{ name: string; kind: string }>;
+  modified: Array<{ name: string; kind: string; line: number }>;
+}
+
+export function diffSymbols(oldSymbols: SymbolEntry[], newSymbols: SymbolEntry[]): SymbolDiff {
+  const oldMap = new Map<string, SymbolEntry>();
   for (const s of oldSymbols) {
     oldMap.set(`${s.name}\0${s.kind}`, s);
   }
 
-  const newMap = new Map();
+  const newMap = new Map<string, SymbolEntry>();
   for (const s of newSymbols) {
     newMap.set(`${s.name}\0${s.kind}`, s);
   }
 
-  const added = [];
-  const removed = [];
-  const modified = [];
+  const added: SymbolDiff['added'] = [];
+  const removed: SymbolDiff['removed'] = [];
+  const modified: SymbolDiff['modified'] = [];
 
   for (const [key, s] of newMap) {
     const old = oldMap.get(key);
@@ -54,10 +54,29 @@ export function diffSymbols(oldSymbols, newSymbols) {
   return { added, removed, modified };
 }
 
-/**
- * Assemble a single change event object.
- */
-export function buildChangeEvent(file, event, symbolDiff, counts) {
+interface ChangeEvent {
+  ts: string;
+  file: string;
+  event: string;
+  symbols: unknown;
+  counts: {
+    nodes: { before: number; after: number };
+    edges: { added: number };
+  };
+}
+
+interface ChangeEventCounts {
+  nodesBefore?: number;
+  nodesAfter?: number;
+  edgesAdded?: number;
+}
+
+export function buildChangeEvent(
+  file: string,
+  event: string,
+  symbolDiff: unknown,
+  counts: ChangeEventCounts,
+): ChangeEvent {
   return {
     ts: new Date().toISOString(),
     file,
@@ -70,11 +89,7 @@ export function buildChangeEvent(file, event, symbolDiff, counts) {
   };
 }
 
-/**
- * Append change events as NDJSON lines to the change events file.
- * Creates the .codegraph directory if needed. Non-fatal on failure.
- */
-export function appendChangeEvents(rootDir, events) {
+export function appendChangeEvents(rootDir: string, events: ChangeEvent[]): void {
   const filePath = changeEventsPath(rootDir);
   const dir = path.dirname(filePath);
 
@@ -86,7 +101,7 @@ export function appendChangeEvents(rootDir, events) {
     fs.appendFileSync(filePath, lines);
     debug(`Appended ${events.length} change event(s) to ${filePath}`);
   } catch (err) {
-    warn(`Failed to append change events: ${err.message}`);
+    warn(`Failed to append change events: ${(err as Error).message}`);
     return;
   }
 
@@ -97,16 +112,12 @@ export function appendChangeEvents(rootDir, events) {
   }
 }
 
-/**
- * If the file exceeds maxBytes, keep the last ~half by finding
- * the first newline at or after the midpoint and rewriting from there.
- */
-export function rotateIfNeeded(filePath, maxBytes = DEFAULT_MAX_BYTES) {
-  let stat;
+export function rotateIfNeeded(filePath: string, maxBytes: number = DEFAULT_MAX_BYTES): void {
+  let stat: fs.Stats;
   try {
     stat = fs.statSync(filePath);
   } catch {
-    return; // file doesn't exist, nothing to rotate
+    return;
   }
 
   if (stat.size <= maxBytes) return;
@@ -125,6 +136,6 @@ export function rotateIfNeeded(filePath, maxBytes = DEFAULT_MAX_BYTES) {
     fs.writeFileSync(filePath, kept);
     debug(`Rotated change events: ${stat.size} → ${kept.length} bytes`);
   } catch (err) {
-    warn(`Failed to rotate change events: ${err.message}`);
+    warn(`Failed to rotate change events: ${(err as Error).message}`);
   }
 }

package/src/domain/graph/cycles.ts

@@ -0,0 +1,66 @@
+import { tarjan } from '../../graph/algorithms/tarjan.js';
+import { buildDependencyGraph } from '../../graph/builders/dependency.js';
+import { CodeGraph } from '../../graph/model.js';
+import { loadNative } from '../../infrastructure/native.js';
+import type { BetterSqlite3Database } from '../../types.js';
+
+export function findCycles(
+  db: BetterSqlite3Database,
+  opts: { fileLevel?: boolean; noTests?: boolean } = {},
+): string[][] {
+  const fileLevel = opts.fileLevel !== false;
+  const noTests = opts.noTests || false;
+
+  const graph = buildDependencyGraph(db, { fileLevel, noTests });
+
+  const idToLabel = new Map<string, string>();
+  for (const [id, attrs] of graph.nodes()) {
+    if (fileLevel) {
+      idToLabel.set(id, attrs['file'] as string);
+    } else {
+      idToLabel.set(id, `${attrs['label']}|${attrs['file']}`);
+    }
+  }
+
+  const edges = graph.toEdgeArray().map((e) => ({
+    source: idToLabel.get(e.source) ?? e.source,
+    target: idToLabel.get(e.target) ?? e.target,
+  }));
+
+  const native = loadNative();
+  if (native) {
+    return native.detectCycles(edges) as string[][];
+  }
+
+  const labelGraph = new CodeGraph();
+  for (const { source, target } of edges) {
+    labelGraph.addEdge(source, target);
+  }
+  return tarjan(labelGraph);
+}
+
+export function findCyclesJS(edges: Array<{ source: string; target: string }>): string[][] {
+  const graph = new CodeGraph();
+  for (const { source, target } of edges) {
+    graph.addEdge(source, target);
+  }
+  return tarjan(graph);
+}
+
+export function formatCycles(cycles: string[][]): string {
+  if (cycles.length === 0) {
+    return 'No circular dependencies detected.';
+  }
+
+  const lines: string[] = [`Found ${cycles.length} circular dependency cycle(s):\n`];
+  for (let i = 0; i < cycles.length; i++) {
+    const cycle = cycles[i]!;
+    lines.push(`  Cycle ${i + 1} (${cycle.length} files):`);
+    for (const file of cycle) {
+      lines.push(`    -> ${file}`);
+    }
+    lines.push(`    -> ${cycle[0]} (back to start)`);
+    lines.push('');
+  }
+  return lines.join('\n');
+}

package/src/domain/graph/{journal.js → journal.ts}

@@ -5,13 +5,16 @@ import { debug, warn } from '../../infrastructure/logger.js';
 export const JOURNAL_FILENAME = 'changes.journal';
 const HEADER_PREFIX = '# codegraph-journal v1 ';
 
-/**
- * Read and validate the change journal.
- * Returns { valid, timestamp, changed[], removed[] } or { valid: false }.
- */
-export function readJournal(rootDir) {
+interface JournalResult {
+  valid: boolean;
+  timestamp?: number;
+  changed?: string[];
+  removed?: string[];
+}
+
+export function readJournal(rootDir: string): JournalResult {
   const journalPath = path.join(rootDir, '.codegraph', JOURNAL_FILENAME);
-  let content;
+  let content: string;
   try {
     content = fs.readFileSync(journalPath, 'utf-8');
   } catch {
@@ -19,24 +22,24 @@ export function readJournal(rootDir) {
   }
 
   const lines = content.split('\n');
-  if (lines.length === 0 || !lines[0].startsWith(HEADER_PREFIX)) {
+  if (lines.length === 0 || !lines[0]!.startsWith(HEADER_PREFIX)) {
     debug('Journal has malformed or missing header');
     return { valid: false };
   }
 
-  const timestamp = Number(lines[0].slice(HEADER_PREFIX.length).trim());
+  const timestamp = Number(lines[0]!.slice(HEADER_PREFIX.length).trim());
   if (!Number.isFinite(timestamp) || timestamp <= 0) {
     debug('Journal has invalid timestamp');
     return { valid: false };
   }
 
-  const changed = [];
-  const removed = [];
-  const seenChanged = new Set();
-  const seenRemoved = new Set();
+  const changed: string[] = [];
+  const removed: string[] = [];
+  const seenChanged = new Set<string>();
+  const seenRemoved = new Set<string>();
 
   for (let i = 1; i < lines.length; i++) {
-    const line = lines[i].trim();
+    const line = lines[i]!.trim();
     if (!line || line.startsWith('#')) continue;
 
     if (line.startsWith('DELETED ')) {
@@ -56,11 +59,10 @@ export function readJournal(rootDir) {
   return { valid: true, timestamp, changed, removed };
 }
 
-/**
- * Append changed/deleted paths to the journal.
- * Creates the journal with a header if it doesn't exist.
- */
-export function appendJournalEntries(rootDir, entries) {
+export function appendJournalEntries(
+  rootDir: string,
+  entries: Array<{ file: string; deleted?: boolean }>,
+): void {
   const dir = path.join(rootDir, '.codegraph');
   const journalPath = path.join(dir, JOURNAL_FILENAME);
 
@@ -68,7 +70,6 @@ export function appendJournalEntries(rootDir, entries) {
     fs.mkdirSync(dir, { recursive: true });
   }
 
-  // If journal doesn't exist, create with a placeholder header
   if (!fs.existsSync(journalPath)) {
     fs.writeFileSync(journalPath, `${HEADER_PREFIX}0\n`);
   }
@@ -81,11 +82,7 @@ export function appendJournalEntries(rootDir, entries) {
   fs.appendFileSync(journalPath, `${lines.join('\n')}\n`);
 }
 
-/**
- * Write a fresh journal header after a successful build.
- * Atomic: write to temp file then rename.
- */
-export function writeJournalHeader(rootDir, timestamp) {
+export function writeJournalHeader(rootDir: string, timestamp: number): void {
   const dir = path.join(rootDir, '.codegraph');
   const journalPath = path.join(dir, JOURNAL_FILENAME);
   const tmpPath = `${journalPath}.tmp`;
@@ -98,8 +95,7 @@ export function writeJournalHeader(rootDir, timestamp) {
     fs.writeFileSync(tmpPath, `${HEADER_PREFIX}${timestamp}\n`);
     fs.renameSync(tmpPath, journalPath);
   } catch (err) {
-    warn(`Failed to write journal header: ${err.message}`);
-    // Clean up temp file if rename failed
+    warn(`Failed to write journal header: ${(err as Error).message}`);
     try {
       fs.unlinkSync(tmpPath);
     } catch {

package/src/domain/graph/{resolve.js → resolve.ts}

@@ -2,11 +2,13 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { loadNative } from '../../infrastructure/native.js';
 import { normalizePath } from '../../shared/constants.js';
+import type { BareSpecifier, BatchResolvedMap, ImportBatchItem, PathAliases } from '../../types.js';
 
 // ── package.json exports resolution ─────────────────────────────────
 
 /** Cache: packageDir → parsed exports field (or null) */
-const _exportsCache = new Map();
+// biome-ignore lint/suspicious/noExplicitAny: package.json exports field has no fixed schema
+const _exportsCache: Map<string, any> = new Map();
 
 /**
  * Parse a bare specifier into { packageName, subpath }.
@@ -14,8 +16,8 @@ const _exportsCache = new Map();
  * Plain:  "pkg/sub"        → { packageName: "pkg", subpath: "./sub" }
  * No sub: "pkg"            → { packageName: "pkg", subpath: "." }
  */
-export function parseBareSpecifier(specifier) {
-  let packageName, rest;
+export function parseBareSpecifier(specifier: string): BareSpecifier | null {
+  let packageName: string, rest: string;
   if (specifier.startsWith('@')) {
     const parts = specifier.split('/');
     if (parts.length < 2) return null;
@@ -38,7 +40,7 @@ export function parseBareSpecifier(specifier) {
  * Find the package directory for a given package name, starting from rootDir.
  * Walks up node_modules directories.
  */
-function findPackageDir(packageName, rootDir) {
+function findPackageDir(packageName: string, rootDir: string): string | null {
   let dir = rootDir;
   while (true) {
     const candidate = path.join(dir, 'node_modules', packageName);
@@ -53,7 +55,8 @@ function findPackageDir(packageName, rootDir) {
  * Read and cache the exports field from a package's package.json.
  * Returns the exports value or null.
  */
-function getPackageExports(packageDir) {
+// biome-ignore lint/suspicious/noExplicitAny: package.json exports field has no fixed schema
+function getPackageExports(packageDir: string): any {
   if (_exportsCache.has(packageDir)) return _exportsCache.get(packageDir);
   try {
     const raw = fs.readFileSync(path.join(packageDir, 'package.json'), 'utf8');
@@ -68,13 +71,13 @@ function getPackageExports(packageDir) {
 }
 
 /** Condition names to try, in priority order. */
-const CONDITION_ORDER = ['import', 'require', 'default'];
+const CONDITION_ORDER: readonly string[] = ['import', 'require', 'default'];
 
 /**
  * Resolve a conditional exports value (string, object with conditions, or array).
  * Returns a string target or null.
  */
-function resolveCondition(value) {
+function resolveCondition(value: unknown): string | null {
   if (typeof value === 'string') return value;
   if (Array.isArray(value)) {
     for (const item of value) {
@@ -85,7 +88,8 @@ function resolveCondition(value) {
   }
   if (value && typeof value === 'object') {
     for (const cond of CONDITION_ORDER) {
-      if (cond in value) return resolveCondition(value[cond]);
+      if (cond in (value as Record<string, unknown>))
+        return resolveCondition((value as Record<string, unknown>)[cond]);
     }
     return null;
   }
@@ -96,7 +100,7 @@ function resolveCondition(value) {
  * Match a subpath against an exports map key that uses a wildcard pattern.
  * Key: "./lib/*" matches subpath "./lib/foo/bar" → substitution "foo/bar"
  */
-function matchSubpathPattern(pattern, subpath) {
+function matchSubpathPattern(pattern: string, subpath: string): string | null {
   const starIdx = pattern.indexOf('*');
   if (starIdx === -1) return null;
   const prefix = pattern.slice(0, starIdx);
@@ -112,7 +116,7 @@ function matchSubpathPattern(pattern, subpath) {
  * Resolve a bare specifier through the package.json exports field.
  * Returns an absolute path or null.
  */
-export function resolveViaExports(specifier, rootDir) {
+export function resolveViaExports(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
 
@@ -189,25 +193,26 @@ export function resolveViaExports(specifier, rootDir) {
 }
 
 /** Clear the exports cache (for testing). */
-export function clearExportsCache() {
+export function clearExportsCache(): void {
   _exportsCache.clear();
 }
 
 // ── Monorepo workspace resolution ───────────────────────────────────
 
 /** Cache: rootDir → Map<packageName, { dir, entry }> */
-const _workspaceCache = new Map();
+const _workspaceCache: Map<string, Map<string, { dir: string; entry: string | null }>> = new Map();
 
 /** Set of resolved relative paths that came from workspace resolution. */
-const _workspaceResolvedPaths = new Set();
+const _workspaceResolvedPaths: Set<string> = new Set();
 
 /**
  * Set the workspace map for a given rootDir.
  * Called by the build pipeline after detecting workspaces.
- * @param {string} rootDir
- * @param {Map<string, { dir: string, entry: string|null }>} map
  */
-export function setWorkspaces(rootDir, map) {
+export function setWorkspaces(
+  rootDir: string,
+  map: Map<string, { dir: string; entry: string | null }>,
+): void {
   _workspaceCache.set(rootDir, map);
   _workspaceResolvedPaths.clear();
   _exportsCache.clear();
@@ -216,7 +221,7 @@ export function setWorkspaces(rootDir, map) {
 /**
  * Get workspace packages for a rootDir. Returns empty map if not set.
  */
-function getWorkspaces(rootDir) {
+function getWorkspaces(rootDir: string): Map<string, { dir: string; entry: string | null }> {
   return _workspaceCache.get(rootDir) || new Map();
 }
 
@@ -226,9 +231,9 @@ function getWorkspaces(rootDir) {
  * For "@myorg/utils" → finds the workspace package dir → resolves entry point.
  * For "@myorg/utils/sub" → finds package dir → tries exports field → filesystem probe.
  *
- * @returns {string|null} Absolute path to resolved file, or null.
+ * @returns Absolute path to resolved file, or null.
  */
-export function resolveViaWorkspace(specifier, rootDir) {
+export function resolveViaWorkspace(specifier: string, rootDir: string): string | null {
   const parsed = parseBareSpecifier(specifier);
   if (!parsed) return null;
 
@@ -293,23 +298,77 @@ export function resolveViaWorkspace(specifier, rootDir) {
  * Check if a resolved relative path was resolved via workspace detection.
  * Used by computeConfidence to assign high confidence (0.95) to workspace imports.
  */
-export function isWorkspaceResolved(resolvedPath) {
+export function isWorkspaceResolved(resolvedPath: string): boolean {
   return _workspaceResolvedPaths.has(resolvedPath);
 }
 
 /** Clear workspace caches (for testing). */
-export function clearWorkspaceCache() {
+export function clearWorkspaceCache(): void {
   _workspaceCache.clear();
   _workspaceResolvedPaths.clear();
 }
 
+// ── JS → TS extension remap cache ───────────────────────────────────
+
+/** Cache: absolute .js path → remapped .ts/.tsx relative path (or null if no TS file exists). */
+const _jsToTsCache: Map<string, string | null> = new Map();
+
+/**
+ * If `resolved` ends with `.js`, check whether a `.ts` or `.tsx` counterpart
+ * exists on disk and return its relative path from `rootDir`.  Results are
+ * cached for the lifetime of the process to avoid repeated stat calls in the
+ * batch hot path.
+ *
+ * The cache stores **absolute** `.ts`/`.tsx` paths (or `null`) so that the
+ * same cached entry is correct regardless of which `rootDir` is passed — the
+ * relative path is computed on every cache hit.  This is important for MCP
+ * `--multi-repo` mode where the same absolute `.js` file may be resolved with
+ * different `rootDir` values.
+ *
+ * Always returns a normalised relative path from `rootDir` — both the remap
+ * branch and the fallback compute `path.relative(rootDir, abs)` to ensure a
+ * consistent format regardless of whether the native resolver returned an
+ * absolute or relative path.
+ */
+function remapJsToTs(resolved: string, rootDir: string): string {
+  if (!resolved.endsWith('.js')) return resolved;
+  const abs = path.resolve(rootDir, resolved);
+  if (_jsToTsCache.has(abs)) {
+    const cachedAbs = _jsToTsCache.get(abs);
+    return cachedAbs
+      ? normalizePath(path.relative(rootDir, cachedAbs))
+      : normalizePath(path.relative(rootDir, abs));
+  }
+  const tsAbs = abs.replace(/\.js$/, '.ts');
+  if (fs.existsSync(tsAbs)) {
+    _jsToTsCache.set(abs, tsAbs);
+    return normalizePath(path.relative(rootDir, tsAbs));
+  }
+  const tsxAbs = abs.replace(/\.js$/, '.tsx');
+  if (fs.existsSync(tsxAbs)) {
+    _jsToTsCache.set(abs, tsxAbs);
+    return normalizePath(path.relative(rootDir, tsxAbs));
+  }
+  _jsToTsCache.set(abs, null);
+  // Normalise fallback to relative to stay consistent with the remap branch —
+  // avoids a format mismatch if the native resolver ever returns an absolute path.
+  return normalizePath(path.relative(rootDir, abs));
+}
+
+/** Clear the .js → .ts remap cache (for testing). */
+export function clearJsToTsCache(): void {
+  _jsToTsCache.clear();
+}
+
 // ── Alias format conversion ─────────────────────────────────────────
 
 /**
  * Convert JS alias format { baseUrl, paths: { pattern: [targets] } }
  * to native format { baseUrl, paths: [{ pattern, targets }] }.
  */
-export function convertAliasesForNative(aliases) {
+export function convertAliasesForNative(
+  aliases: PathAliases | null | undefined,
+): { baseUrl: string; paths: { pattern: string; targets: string[] }[] } | null {
   if (!aliases) return null;
   return {
     baseUrl: aliases.baseUrl || '',
@@ -322,7 +381,11 @@ export function convertAliasesForNative(aliases) {
 
 // ── JS fallback implementations ─────────────────────────────────────
 
-function resolveViaAlias(importSource, aliases, _rootDir) {
+function resolveViaAlias(
+  importSource: string,
+  aliases: PathAliases,
+  _rootDir: string,
+): string | null {
   if (aliases.baseUrl && !importSource.startsWith('.') && !importSource.startsWith('/')) {
     const candidate = path.resolve(aliases.baseUrl, importSource);
     for (const ext of ['', '.ts', '.tsx', '.js', '.jsx', '/index.ts', '/index.tsx', '/index.js']) {
@@ -355,7 +418,12 @@ function resolveViaAlias(importSource, aliases, _rootDir) {
   return null;
 }
 
-function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
+function resolveImportPathJS(
+  fromFile: string,
+  importSource: string,
+  rootDir: string,
+  aliases: PathAliases | null,
+): string {
   if (!importSource.startsWith('.') && aliases) {
     const aliasResolved = resolveViaAlias(importSource, aliases, rootDir);
     if (aliasResolved) return normalizePath(path.relative(rootDir, aliasResolved));
@@ -404,7 +472,11 @@ function resolveImportPathJS(fromFile, importSource, rootDir, aliases) {
   return normalizePath(path.relative(rootDir, resolved));
 }
 
-function computeConfidenceJS(callerFile, targetFile, importedFrom) {
+function computeConfidenceJS(
+  callerFile: string,
+  targetFile: string,
+  importedFrom: string | null,
+): number {
   if (!targetFile || !callerFile) return 0.3;
   if (callerFile === targetFile) return 1.0;
   if (importedFrom === targetFile) return 1.0;
@@ -423,7 +495,12 @@ function computeConfidenceJS(callerFile, targetFile, importedFrom) {
  * Resolve a single import path.
  * Tries native, falls back to JS.
  */
-export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
+export function resolveImportPath(
+  fromFile: string,
+  importSource: string,
+  rootDir: string,
+  aliases: PathAliases | null,
+): string {
   const native = loadNative();
   if (native) {
     try {
@@ -433,7 +510,11 @@ export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
         rootDir,
         convertAliasesForNative(aliases),
       );
-      return normalizePath(path.normalize(result));
+      const normalized = normalizePath(path.normalize(result));
+      // The native resolver's .js → .ts remap fails when paths contain
+      // unresolved ".." components (PathBuf::components().collect() doesn't
+      // collapse parent refs). Apply the remap on the JS side as a fallback.
+      return remapJsToTs(normalized, rootDir);
     } catch {
       // fall through to JS
     }
@@ -445,7 +526,11 @@ export function resolveImportPath(fromFile, importSource, rootDir, aliases) {
  * Compute proximity-based confidence for call resolution.
  * Tries native, falls back to JS.
  */
-export function computeConfidence(callerFile, targetFile, importedFrom) {
+export function computeConfidence(
+  callerFile: string,
+  targetFile: string,
+  importedFrom: string | null,
+): number {
   const native = loadNative();
   if (native) {
     try {
@@ -460,12 +545,13 @@ export function computeConfidence(callerFile, targetFile, importedFrom) {
 /**
  * Batch resolve multiple imports in a single native call.
  * Returns Map<"fromFile|importSource", resolvedPath> or null when native unavailable.
- * @param {Array} inputs - Array of { fromFile, importSource }
- * @param {string} rootDir - Project root
- * @param {object} aliases - Path aliases
- * @param {string[]} [knownFiles] - Optional file paths for FS cache (avoids syscalls)
  */
-export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
+export function resolveImportsBatch(
+  inputs: ImportBatchItem[],
+  rootDir: string,
+  aliases: PathAliases | null,
+  knownFiles?: string[] | null,
+): BatchResolvedMap | null {
   const native = loadNative();
   if (!native) return null;
 
@@ -480,9 +566,13 @@ export function resolveImportsBatch(inputs, rootDir, aliases, knownFiles) {
       convertAliasesForNative(aliases),
       knownFiles || null,
     );
-    const map = new Map();
+    const map: BatchResolvedMap = new Map();
     for (const r of results) {
-      map.set(`${r.fromFile}|${r.importSource}`, normalizePath(path.normalize(r.resolvedPath)));
+      const normalized = normalizePath(path.normalize(r.resolvedPath));
+      // Native resolver's .js → .ts remap fails on unnormalized paths —
+      // apply JS-side fallback (same fix as resolveImportPath).
+      const resolved = remapJsToTs(normalized, rootDir);
+      map.set(`${r.fromFile}|${r.importSource}`, resolved);
     }
     return map;
   } catch {