grepmind-core 0.1.0-alpha

package/dist/indexer/code/graph/resolver.js

@@ -0,0 +1,839 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { builtinModules, createRequire } from 'node:module';
+import { pathToFileURL } from 'node:url';
+const EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+const TS_COMPAT_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.mjs', '.cjs', '.json'];
+const BUILTIN_SET = new Set([
+    ...builtinModules,
+    ...builtinModules.map((m) => `node:${m}`),
+]);
+/**
+ * File system cache for resolver operations.
+ * Caches access and stat results to avoid redundant I/O during graph building.
+ */
+class FSCache {
+    accessCache = new Map();
+    statCache = new Map();
+    realpathCache = new Map();
+    pendingAccess = new Map();
+    pendingStat = new Map();
+    pendingRealpath = new Map();
+    async access(filePath) {
+        if (this.accessCache.has(filePath)) {
+            return this.accessCache.get(filePath);
+        }
+        // Deduplicate concurrent requests for the same path
+        if (this.pendingAccess.has(filePath)) {
+            return this.pendingAccess.get(filePath);
+        }
+        const promise = (async () => {
+            try {
+                await fs.access(filePath);
+                this.accessCache.set(filePath, true);
+                return true;
+            }
+            catch {
+                this.accessCache.set(filePath, false);
+                return false;
+            }
+            finally {
+                this.pendingAccess.delete(filePath);
+            }
+        })();
+        this.pendingAccess.set(filePath, promise);
+        return promise;
+    }
+    async stat(filePath) {
+        if (this.statCache.has(filePath)) {
+            return this.statCache.get(filePath);
+        }
+        if (this.pendingStat.has(filePath)) {
+            return this.pendingStat.get(filePath);
+        }
+        const promise = (async () => {
+            try {
+                const result = await fs.stat(filePath);
+                this.statCache.set(filePath, result);
+                return result;
+            }
+            catch {
+                this.statCache.set(filePath, null);
+                return null;
+            }
+            finally {
+                this.pendingStat.delete(filePath);
+            }
+        })();
+        this.pendingStat.set(filePath, promise);
+        return promise;
+    }
+    async realpath(filePath) {
+        if (this.realpathCache.has(filePath)) {
+            return this.realpathCache.get(filePath);
+        }
+        if (this.pendingRealpath.has(filePath)) {
+            return this.pendingRealpath.get(filePath);
+        }
+        const promise = (async () => {
+            try {
+                const result = await fs.realpath(filePath);
+                this.realpathCache.set(filePath, result);
+                return result;
+            }
+            catch {
+                this.realpathCache.set(filePath, null);
+                return null;
+            }
+            finally {
+                this.pendingRealpath.delete(filePath);
+            }
+        })();
+        this.pendingRealpath.set(filePath, promise);
+        return promise;
+    }
+    clear() {
+        this.accessCache.clear();
+        this.statCache.clear();
+        this.realpathCache.clear();
+        this.pendingAccess.clear();
+        this.pendingStat.clear();
+        this.pendingRealpath.clear();
+    }
+    get size() {
+        return this.accessCache.size + this.statCache.size + this.realpathCache.size;
+    }
+}
+// Global FS cache instance for resolver operations
+const fsCache = new FSCache();
+/**
+ * Clear the resolver file system cache.
+ * Call this between indexing runs or when files may have changed.
+ */
+export function clearResolverCache() {
+    fsCache.clear();
+}
+/**
+ * Resolves workspace package imports to source files.
+ * Works with npm/yarn/pnpm workspaces by detecting symlinks in node_modules.
+ */
+export class WorkspaceResolver {
+    workspaces = new Map();
+    rootPath;
+    workspaceRoot = null;
+    discovered = false;
+    constructor(rootPath) {
+        this.rootPath = rootPath;
+    }
+    /**
+     * Get the workspace root directory (where package.json with workspaces is located).
+     */
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
+    /**
+     * Get the root directory path for a workspace package.
+     * @param packageName - Package name (e.g., grepmind-config)
+     * @returns Relative path to package root (e.g., packages/config) or null
+     */
+    getPackagePath(packageName) {
+        const ws = this.workspaces.get(packageName);
+        return ws?.rootDir ?? null;
+    }
+    /**
+     * Discover all workspace packages in the project.
+     * Walks up from rootPath to find workspace root, then discovers all packages.
+     */
+    async discover() {
+        if (this.discovered)
+            return;
+        this.discovered = true;
+        // Find workspace root by walking up the directory tree
+        this.workspaceRoot = await this.findWorkspaceRoot();
+        if (!this.workspaceRoot)
+            return;
+        const patterns = await this.getWorkspacePatterns();
+        if (patterns.length === 0)
+            return;
+        // Import glob dynamically to avoid circular dependencies
+        const { glob } = await import('glob');
+        for (const pattern of patterns) {
+            // Glob for package.json files inside workspace patterns
+            const pkgJsonPattern = `${pattern}/package.json`;
+            const pkgJsonFiles = await glob(pkgJsonPattern, {
+                cwd: this.workspaceRoot,
+                absolute: false,
+                nodir: true,
+            });
+            for (const pkgJsonPath of pkgJsonFiles) {
+                // Extract directory from package.json path
+                const dir = path.dirname(pkgJsonPath);
+                await this.registerWorkspace(dir);
+            }
+        }
+    }
+    /**
+     * Check if rootPath is a workspace root.
+     * Returns rootPath if it contains package.json with workspaces or pnpm-workspace.yaml.
+     * Does NOT walk up the tree — rootPath is the config root and nothing above it should be indexed.
+     */
+    async findWorkspaceRoot() {
+        // Check for npm/yarn workspaces in package.json
+        try {
+            const pkgPath = path.join(this.rootPath, 'package.json');
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (Array.isArray(pkg.workspaces)) {
+                return this.rootPath;
+            }
+            if (typeof pkg.workspaces === 'object' && pkg.workspaces !== null) {
+                const ws = pkg.workspaces;
+                if (Array.isArray(ws.packages)) {
+                    return this.rootPath;
+                }
+            }
+        }
+        catch {
+            // No package.json or invalid
+        }
+        // Check for pnpm-workspace.yaml
+        try {
+            const yamlPath = path.join(this.rootPath, 'pnpm-workspace.yaml');
+            await fs.access(yamlPath);
+            return this.rootPath;
+        }
+        catch {
+            // No pnpm-workspace.yaml
+        }
+        return null;
+    }
+    /**
+     * Get workspace patterns from package.json or pnpm-workspace.yaml
+     */
+    async getWorkspacePatterns() {
+        if (!this.workspaceRoot)
+            return [];
+        // Try package.json first (npm/yarn workspaces)
+        try {
+            const pkgPath = path.join(this.workspaceRoot, 'package.json');
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            // npm/yarn: workspaces: ["packages/*"]
+            if (Array.isArray(pkg.workspaces)) {
+                return pkg.workspaces;
+            }
+            // yarn: workspaces.packages: ["packages/*"]
+            if (typeof pkg.workspaces === 'object' && pkg.workspaces !== null) {
+                const ws = pkg.workspaces;
+                if (Array.isArray(ws.packages)) {
+                    return ws.packages;
+                }
+            }
+        }
+        catch {
+            // No package.json or invalid
+        }
+        // Try pnpm-workspace.yaml
+        try {
+            const yamlPath = path.join(this.workspaceRoot, 'pnpm-workspace.yaml');
+            const content = await fs.readFile(yamlPath, 'utf-8');
+            // Simple YAML parsing for packages array
+            const match = content.match(/packages:\s*\n((?:\s+-\s+.+\n?)+)/);
+            if (match) {
+                const lines = match[1].split('\n');
+                return lines
+                    .map(line => line.replace(/^\s*-\s*['"]?/, '').replace(/['"]?\s*$/, ''))
+                    .filter(Boolean);
+            }
+        }
+        catch {
+            // No pnpm-workspace.yaml
+        }
+        return [];
+    }
+    /**
+     * Register a workspace package directory.
+     */
+    async registerWorkspace(dir) {
+        if (!this.workspaceRoot)
+            return;
+        const pkgPath = path.join(this.workspaceRoot, dir, 'package.json');
+        try {
+            const content = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            const name = pkg.name;
+            if (!name)
+                return;
+            // Load tsconfig to get src/dist directories
+            const tsconfig = await loadTSConfig(path.join(this.workspaceRoot, dir));
+            // Normalize paths: remove leading ./
+            const srcDir = (tsconfig?.compilerOptions?.rootDir ?? 'src').replace(/^\.\//, '');
+            const distDir = (tsconfig?.compilerOptions?.outDir ?? 'dist').replace(/^\.\//, '');
+            // Parse exports field
+            let exports = null;
+            if (typeof pkg.exports === 'object' && pkg.exports !== null) {
+                exports = this.normalizeExports(pkg.exports);
+            }
+            this.workspaces.set(name, {
+                name,
+                rootDir: dir,
+                srcDir,
+                distDir,
+                exports,
+            });
+        }
+        catch {
+            // Skip invalid packages
+        }
+    }
+    /**
+     * Normalize package.json exports to a simple path map.
+     */
+    normalizeExports(exports) {
+        const result = {};
+        for (const [key, value] of Object.entries(exports)) {
+            if (typeof value === 'string') {
+                result[key] = value;
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Handle conditional exports: { import: "./dist/index.js", types: "..." }
+                const cond = value;
+                const importPath = cond.import ?? cond.require ?? cond.default;
+                if (typeof importPath === 'string') {
+                    result[key] = importPath;
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Check if a package name is a workspace package.
+     */
+    isWorkspacePackage(packageName) {
+        return this.workspaces.has(packageName);
+    }
+    /**
+     * Resolve a workspace package import to source file path.
+     * Returns ABSOLUTE path to source file, or null if not resolvable.
+     *
+     * @param packageName - Package name (e.g., grepmind-config)
+     * @param subpath - Optional subpath (e.g., utils for grepmind-config/utils)
+     */
+    resolveToSource(packageName, subpath) {
+        const ws = this.workspaces.get(packageName);
+        if (!ws || !this.workspaceRoot)
+            return null;
+        // Resolve through exports field if available
+        let distPath;
+        if (ws.exports) {
+            const exportKey = subpath ? `./${subpath}` : '.';
+            const exportPath = ws.exports[exportKey];
+            if (exportPath) {
+                // Remove leading ./ from export path
+                distPath = exportPath.replace(/^\.\//, '');
+            }
+            else {
+                // Fallback: assume direct subpath mapping
+                distPath = subpath
+                    ? `${ws.distDir}/${subpath}`
+                    : `${ws.distDir}/index.js`;
+            }
+        }
+        else {
+            distPath = subpath
+                ? `${ws.distDir}/${subpath}`
+                : `${ws.distDir}/index.js`;
+        }
+        // Map dist → src, .js → .ts
+        // Escape regex special chars in distDir (e.g., if distDir contains dots)
+        const escapedDistDir = ws.distDir.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        const srcPath = distPath
+            .replace(new RegExp(`^${escapedDistDir}/`), `${ws.srcDir}/`)
+            .replace(/\.js$/, '.ts')
+            .replace(/\.mjs$/, '.mts')
+            .replace(/\.cjs$/, '.cts');
+        // Return absolute path
+        return path.join(this.workspaceRoot, ws.rootDir, srcPath);
+    }
+    /**
+     * Get all discovered workspace packages.
+     */
+    getWorkspaces() {
+        return this.workspaces;
+    }
+    /**
+     * Clear discovered workspaces (for testing or re-discovery).
+     */
+    clear() {
+        this.workspaces.clear();
+        this.discovered = false;
+    }
+}
+async function safeAccess(filePath) {
+    return fsCache.access(filePath);
+}
+async function safeStat(filePath) {
+    return fsCache.stat(filePath);
+}
+function toFileId(rootPath, absolutePath) {
+    return path.relative(rootPath, absolutePath).replace(/\\/g, '/');
+}
+async function resolveWithExtensions(basePath) {
+    const stat = await safeStat(basePath);
+    if (stat?.isFile())
+        return basePath;
+    // Build all candidates upfront
+    const candidates = [];
+    for (const ext of EXTENSIONS) {
+        candidates.push(`${basePath}${ext}`);
+    }
+    for (const ext of EXTENSIONS) {
+        candidates.push(path.join(basePath, `index${ext}`));
+    }
+    // Check all candidates in parallel
+    const results = await Promise.all(candidates.map(async (candidate) => ({
+        candidate,
+        exists: await safeAccess(candidate),
+    })));
+    // Return first existing candidate (preserves priority order)
+    for (const { candidate, exists } of results) {
+        if (exists)
+            return candidate;
+    }
+    return null;
+}
+async function resolveWithExtensionList(basePath, extensions) {
+    const stat = await safeStat(basePath);
+    if (stat?.isFile())
+        return basePath;
+    // Build all candidates upfront
+    const candidates = [];
+    for (const ext of extensions) {
+        candidates.push(`${basePath}${ext}`);
+    }
+    for (const ext of extensions) {
+        candidates.push(path.join(basePath, `index${ext}`));
+    }
+    // Check all candidates in parallel
+    const results = await Promise.all(candidates.map(async (candidate) => ({
+        candidate,
+        exists: await safeAccess(candidate),
+    })));
+    // Return first existing candidate (preserves priority order)
+    for (const { candidate, exists } of results) {
+        if (exists)
+            return candidate;
+    }
+    return null;
+}
+function parsePackageSpec(spec) {
+    if (spec.startsWith('@')) {
+        const [scope, name, ...rest] = spec.split('/');
+        return {
+            packageName: `${scope}/${name ?? ''}`,
+            subpath: rest.length > 0 ? rest.join('/') : null,
+        };
+    }
+    const [name, ...rest] = spec.split('/');
+    return {
+        packageName: name,
+        subpath: rest.length > 0 ? rest.join('/') : null,
+    };
+}
+function tryParseJSON(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function stripJsonComments(input) {
+    let out = '';
+    let i = 0;
+    let inString = false;
+    let escaped = false;
+    while (i < input.length) {
+        const char = input[i];
+        const next = input[i + 1];
+        if (inString) {
+            out += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === '\\') {
+                escaped = true;
+            }
+            else if (char === '"') {
+                inString = false;
+            }
+            i++;
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            out += char;
+            i++;
+            continue;
+        }
+        if (char === '/' && next === '/') {
+            i += 2;
+            while (i < input.length && input[i] !== '\n')
+                i++;
+            continue;
+        }
+        if (char === '/' && next === '*') {
+            i += 2;
+            while (i < input.length - 1 && !(input[i] === '*' && input[i + 1] === '/'))
+                i++;
+            i = Math.min(i + 2, input.length);
+            continue;
+        }
+        out += char;
+        i++;
+    }
+    return out;
+}
+export async function loadTSConfig(rootPath, tsConfigPath) {
+    const configPath = tsConfigPath
+        ? path.resolve(rootPath, tsConfigPath)
+        : path.join(rootPath, 'tsconfig.json');
+    try {
+        const content = await fs.readFile(configPath, 'utf-8');
+        const parsed = tryParseJSON(content) ?? tryParseJSON(stripJsonComments(content));
+        if (!parsed)
+            return null;
+        const compilerOptions = (parsed.compilerOptions ?? {});
+        const paths = compilerOptions.paths;
+        const baseUrl = compilerOptions.baseUrl;
+        const rootDir = compilerOptions.rootDir;
+        const outDir = compilerOptions.outDir;
+        return {
+            compilerOptions: {
+                baseUrl,
+                paths,
+                rootDir,
+                outDir,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function resolveRelative(spec, options) {
+    const importerDir = path.dirname(path.resolve(options.rootPath, options.basePath));
+    const targetBase = path.resolve(importerDir, spec);
+    const resolved = await resolveWithExtensions(targetBase);
+    if (resolved) {
+        return {
+            type: 'local',
+            fileId: toFileId(options.rootPath, resolved),
+        };
+    }
+    const specExt = path.extname(spec);
+    if (specExt === '.js' || specExt === '.jsx' || specExt === '.mjs' || specExt === '.cjs') {
+        const targetWithoutExt = targetBase.slice(0, -specExt.length);
+        const tsCompatible = await resolveWithExtensionList(targetWithoutExt, TS_COMPAT_EXTENSIONS);
+        if (tsCompatible) {
+            return {
+                type: 'local',
+                fileId: toFileId(options.rootPath, tsCompatible),
+            };
+        }
+    }
+    return {
+        type: 'unresolved',
+        error: `Relative module not found: ${spec}`,
+    };
+}
+async function resolveTSPaths(spec, options) {
+    if (!options.tsConfig?.compilerOptions?.paths || options.respectTSPaths === false) {
+        return null;
+    }
+    const pathsConfig = options.tsConfig.compilerOptions.paths;
+    const baseUrl = options.tsConfig.compilerOptions.baseUrl
+        ? path.resolve(options.rootPath, options.tsConfig.compilerOptions.baseUrl)
+        : options.rootPath;
+    for (const [pattern, targets] of Object.entries(pathsConfig)) {
+        const wildcardIndex = pattern.indexOf('*');
+        const isWildcard = wildcardIndex >= 0;
+        if (!isWildcard && pattern !== spec) {
+            continue;
+        }
+        if (isWildcard) {
+            const prefix = pattern.slice(0, wildcardIndex);
+            const suffix = pattern.slice(wildcardIndex + 1);
+            if (!spec.startsWith(prefix) || !spec.endsWith(suffix)) {
+                continue;
+            }
+        }
+        for (const targetPattern of targets) {
+            let target = targetPattern;
+            if (isWildcard) {
+                const prefix = pattern.slice(0, wildcardIndex);
+                const suffix = pattern.slice(wildcardIndex + 1);
+                const matched = spec.slice(prefix.length, spec.length - suffix.length);
+                target = targetPattern.replace('*', matched);
+            }
+            const absoluteTarget = path.resolve(baseUrl, target);
+            const resolved = await resolveWithExtensions(absoluteTarget);
+            if (resolved) {
+                return {
+                    type: 'local',
+                    fileId: toFileId(options.rootPath, resolved),
+                };
+            }
+        }
+    }
+    return null;
+}
+async function resolveNodeModule(spec, options) {
+    const { packageName, subpath } = parsePackageSpec(spec);
+    const importerPath = path.resolve(options.rootPath, options.basePath || 'index.ts');
+    const importerDir = path.dirname(importerPath);
+    const isInsideRoot = (absolutePath) => absolutePath === options.rootPath || absolutePath.startsWith(`${options.rootPath}${path.sep}`);
+    const nodeModulesCandidates = [];
+    if (options.nodeModulesPath) {
+        nodeModulesCandidates.push(options.nodeModulesPath);
+    }
+    let cursor = importerDir;
+    while (true) {
+        nodeModulesCandidates.push(path.join(cursor, 'node_modules'));
+        const parent = path.dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    let pkgRoot = null;
+    for (const nodeModulesPath of nodeModulesCandidates) {
+        const candidate = path.join(nodeModulesPath, packageName);
+        if (await safeAccess(candidate)) {
+            pkgRoot = candidate;
+            break;
+        }
+    }
+    if (!pkgRoot) {
+        return {
+            type: 'unresolved',
+            error: `Package not found: ${packageName}`,
+        };
+    }
+    // Check if this is a workspace package (symlink pointing inside workspace root, but NOT in node_modules)
+    if (options.workspaceResolver) {
+        const workspaceRoot = options.workspaceResolver.getWorkspaceRoot();
+        if (workspaceRoot) {
+            const realPath = await fsCache.realpath(pkgRoot);
+            if (realPath) {
+                const relativeToWorkspace = path.relative(workspaceRoot, realPath);
+                // If realpath is inside workspace root (not starting with ..) AND not in node_modules = workspace package
+                // Workspace packages are symlinks that point to actual source directories, not node_modules
+                const isInsideNodeModules = relativeToWorkspace.includes('node_modules');
+                if (!relativeToWorkspace.startsWith('..') && !path.isAbsolute(relativeToWorkspace) && !isInsideNodeModules) {
+                    // Get package path from resolver, fallback to computed relative path
+                    const packagePath = options.workspaceResolver.getPackagePath(packageName) ?? relativeToWorkspace;
+                    return {
+                        type: 'workspace',
+                        module: packageName,
+                        subpath: subpath ?? undefined,
+                        path: packagePath,
+                    };
+                }
+            }
+        }
+    }
+    if (subpath) {
+        const subpathResolved = await resolveWithExtensions(path.join(pkgRoot, subpath));
+        if (subpathResolved) {
+            if (isInsideRoot(subpathResolved)) {
+                return {
+                    type: 'local',
+                    fileId: toFileId(options.rootPath, subpathResolved),
+                    module: packageName,
+                    subpath,
+                };
+            }
+            return {
+                type: 'npm',
+                module: packageName,
+                subpath,
+            };
+        }
+    }
+    const packageJsonPath = path.join(pkgRoot, 'package.json');
+    if (await safeAccess(packageJsonPath)) {
+        try {
+            const packageContent = await fs.readFile(packageJsonPath, 'utf-8');
+            const packageJson = JSON.parse(packageContent);
+            const main = typeof packageJson.module === 'string'
+                ? packageJson.module
+                : typeof packageJson.main === 'string'
+                    ? packageJson.main
+                    : null;
+            if (main) {
+                const mainResolved = await resolveWithExtensions(path.join(pkgRoot, main));
+                if (mainResolved) {
+                    if (isInsideRoot(mainResolved)) {
+                        return {
+                            type: 'local',
+                            fileId: toFileId(options.rootPath, mainResolved),
+                            module: packageName,
+                        };
+                    }
+                    return {
+                        type: 'npm',
+                        module: packageName,
+                        subpath: subpath ?? undefined,
+                    };
+                }
+            }
+        }
+        catch {
+            // ignore invalid package.json and try Node resolver below
+        }
+    }
+    // Prefer Node's real resolver first (exports/main + ancestor node_modules lookup).
+    try {
+        const req = createRequire(pathToFileURL(importerPath).href);
+        const resolvedPath = req.resolve(spec);
+        if (BUILTIN_SET.has(resolvedPath)) {
+            return { type: 'builtin', module: resolvedPath };
+        }
+        if (isInsideRoot(resolvedPath)) {
+            return {
+                type: 'local',
+                fileId: toFileId(options.rootPath, resolvedPath),
+                module: packageName,
+                subpath: subpath ?? undefined,
+            };
+        }
+        return {
+            type: 'npm',
+            module: packageName,
+            subpath: subpath ?? undefined,
+        };
+    }
+    catch {
+        // Fall through to conservative fallback below.
+    }
+    return {
+        type: 'npm',
+        module: packageName,
+        subpath: subpath ?? undefined,
+    };
+}
+export async function resolveModule(spec, options) {
+    if (spec.startsWith('.')) {
+        return resolveRelative(spec, options);
+    }
+    const tsPathResolved = await resolveTSPaths(spec, options);
+    if (tsPathResolved)
+        return tsPathResolved;
+    if (BUILTIN_SET.has(spec)) {
+        return { type: 'builtin', module: spec };
+    }
+    return resolveNodeModule(spec, options);
+}
+export class ExportMapBuilder {
+    exportMap = new Map();
+    factsPerFile = new Map();
+    options;
+    resolveCache = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async buildExportMap(factsPerFile) {
+        this.factsPerFile = factsPerFile;
+        this.exportMap.clear();
+        for (const [fileId, facts] of factsPerFile) {
+            const fileExports = new Map();
+            for (const exp of facts.exports) {
+                if (exp.kind === 'reexport') {
+                    if (exp.name === '*') {
+                        const resolved = await this.resolveReexport(exp, fileId, new Set([fileId]), fileExports);
+                        if (resolved) {
+                            fileExports.set('*', resolved);
+                        }
+                        continue;
+                    }
+                    const resolved = await this.resolveReexport(exp, fileId, new Set([fileId]), fileExports);
+                    if (resolved) {
+                        fileExports.set(exp.name, resolved);
+                    }
+                    continue;
+                }
+                fileExports.set(exp.name, exp.symbolId);
+            }
+            this.exportMap.set(fileId, fileExports);
+        }
+    }
+    async resolveCached(spec, basePath) {
+        const cacheKey = `${basePath}::${spec}`;
+        const cached = this.resolveCache.get(cacheKey);
+        if (cached)
+            return cached;
+        const resolved = await resolveModule(spec, {
+            ...this.options,
+            basePath,
+        });
+        this.resolveCache.set(cacheKey, resolved);
+        return resolved;
+    }
+    async resolveReexport(exp, currentFile, visited, targetMap) {
+        if (!exp.fromSpec)
+            return null;
+        const resolved = await this.resolveCached(exp.fromSpec, currentFile);
+        if (resolved.type !== 'local' || !resolved.fileId) {
+            if (resolved.type === 'npm' || resolved.type === 'builtin' || resolved.type === 'workspace') {
+                return `EXTERNAL:${resolved.module ?? exp.fromSpec}#${exp.name}`;
+            }
+            return null;
+        }
+        const sourceFile = resolved.fileId;
+        if (visited.has(sourceFile)) {
+            return null;
+        }
+        const sourceFacts = this.factsPerFile.get(sourceFile);
+        if (!sourceFacts)
+            return null;
+        if (exp.name === '*') {
+            const localExports = this.exportMap.get(sourceFile);
+            if (localExports) {
+                for (const [name, symbolId] of localExports) {
+                    targetMap.set(name, symbolId);
+                }
+            }
+            return `STAR:${sourceFile}`;
+        }
+        const sourceExport = sourceFacts.exports.find((e) => e.name === exp.name || e.localName === exp.localName);
+        if (!sourceExport)
+            return null;
+        if (sourceExport.kind === 'reexport') {
+            return this.resolveReexport(sourceExport, sourceFile, new Set([...visited, sourceFile]), targetMap);
+        }
+        return sourceExport.symbolId;
+    }
+    resolveImport(fileId, importedName) {
+        const exports = this.exportMap.get(fileId);
+        if (!exports)
+            return null;
+        return exports.get(importedName) ?? exports.get('default') ?? null;
+    }
+    getExportMap() {
+        return this.exportMap;
+    }
+    /**
+     * Get all local files that were resolved during export map building.
+     * This includes files from reexport chains.
+     */
+    getResolvedLocalFiles() {
+        const files = new Set();
+        for (const result of this.resolveCache.values()) {
+            if (result.type === 'local' && result.fileId) {
+                files.add(result.fileId);
+            }
+        }
+        return files;
+    }
+}
+//# sourceMappingURL=resolver.js.map