gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/resolvers/jvm.js

@@ -1,87 +0,0 @@
-/**
- * JVM import resolution (Java + Kotlin).
- * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
- */
-/** Kotlin file extensions for JVM resolver reuse */
-export const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
-/**
- * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
- * Pure function — returns a new string without mutating the input.
- */
-export const appendKotlinWildcard = (importPath, importNode) => {
-    for (let i = 0; i < importNode.childCount; i++) {
-        if (importNode.child(i)?.type === 'wildcard_import') {
-            return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
-        }
-    }
-    return importPath;
-};
-/**
- * Resolve a JVM wildcard import (com.example.*) to all matching files.
- * Works for both Java (.java) and Kotlin (.kt, .kts).
- */
-export function resolveJvmWildcard(importPath, normalizedFileList, allFileList, extensions, index) {
-    // "com.example.util.*" -> "com/example/util"
-    const packagePath = importPath.slice(0, -2).replace(/\./g, '/');
-    if (index) {
-        const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
-        // Filter to only direct children (no subdirectories)
-        const packageSuffix = '/' + packagePath + '/';
-        return candidates.filter(f => {
-            const normalized = f.replace(/\\/g, '/');
-            const idx = normalized.indexOf(packageSuffix);
-            if (idx < 0)
-                return false;
-            const afterPkg = normalized.substring(idx + packageSuffix.length);
-            return !afterPkg.includes('/');
-        });
-    }
-    // Fallback: linear scan
-    const packageSuffix = '/' + packagePath + '/';
-    const matches = [];
-    for (let i = 0; i < normalizedFileList.length; i++) {
-        const normalized = normalizedFileList[i];
-        if (normalized.includes(packageSuffix) &&
-            extensions.some(ext => normalized.endsWith(ext))) {
-            const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length);
-            if (!afterPackage.includes('/')) {
-                matches.push(allFileList[i]);
-            }
-        }
-    }
-    return matches;
-}
-/**
- * Try to resolve a JVM member/static import by stripping the member name.
- * Java: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
- * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
- */
-export function resolveJvmMemberImport(importPath, normalizedFileList, allFileList, extensions, index) {
-    // Member imports: com.example.Constants.VALUE or com.example.Constants.*
-    // The last segment is a member name if it starts with lowercase, is ALL_CAPS, or is a wildcard
-    const segments = importPath.split('.');
-    if (segments.length < 3)
-        return null;
-    const lastSeg = segments[segments.length - 1];
-    if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) {
-        const classPath = segments.slice(0, -1).join('/');
-        for (const ext of extensions) {
-            const classSuffix = classPath + ext;
-            if (index) {
-                const result = index.get(classSuffix) || index.getInsensitive(classSuffix);
-                if (result)
-                    return result;
-            }
-            else {
-                const fullSuffix = '/' + classSuffix;
-                for (let i = 0; i < normalizedFileList.length; i++) {
-                    if (normalizedFileList[i].endsWith(fullSuffix) ||
-                        normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) {
-                        return allFileList[i];
-                    }
-                }
-            }
-        }
-    }
-    return null;
-}

package/dist/core/ingestion/resolvers/php.d.ts

@@ -1,15 +0,0 @@
-/**
- * PHP PSR-4 import resolution.
- * Handles use-statement resolution via composer.json autoload mappings.
- */
-import type { SuffixIndex } from './utils.js';
-/** PHP Composer PSR-4 autoload config */
-export interface ComposerConfig {
-    /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
-    psr4: Map<string, string>;
-}
-/**
- * Resolve a PHP use-statement import path using PSR-4 mappings.
- * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
- */
-export declare function resolvePhpImport(importPath: string, composerConfig: ComposerConfig | null, allFiles: Set<string>, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;

package/dist/core/ingestion/resolvers/php.js

@@ -1,35 +0,0 @@
-/**
- * PHP PSR-4 import resolution.
- * Handles use-statement resolution via composer.json autoload mappings.
- */
-import { suffixResolve } from './utils.js';
-/**
- * Resolve a PHP use-statement import path using PSR-4 mappings.
- * e.g. "App\Http\Controllers\UserController" -> "app/Http/Controllers/UserController.php"
- */
-export function resolvePhpImport(importPath, composerConfig, allFiles, normalizedFileList, allFileList, index) {
-    // Normalize: replace backslashes with forward slashes
-    const normalized = importPath.replace(/\\/g, '/');
-    // Try PSR-4 resolution if composer.json was found
-    if (composerConfig) {
-        // Sort namespaces by length descending (longest match wins)
-        const sorted = [...composerConfig.psr4.entries()].sort((a, b) => b[0].length - a[0].length);
-        for (const [nsPrefix, dirPrefix] of sorted) {
-            const nsPrefixSlash = nsPrefix.replace(/\\/g, '/');
-            if (normalized.startsWith(nsPrefixSlash + '/') || normalized === nsPrefixSlash) {
-                const remainder = normalized.slice(nsPrefixSlash.length).replace(/^\//, '');
-                const filePath = dirPrefix + (remainder ? '/' + remainder : '') + '.php';
-                if (allFiles.has(filePath))
-                    return filePath;
-                if (index) {
-                    const result = index.getInsensitive(filePath);
-                    if (result)
-                        return result;
-                }
-            }
-        }
-    }
-    // Fallback: suffix matching (works without composer.json)
-    const pathParts = normalized.split('/').filter(Boolean);
-    return suffixResolve(pathParts, normalizedFileList, allFileList, index);
-}

package/dist/core/ingestion/resolvers/rust.d.ts

@@ -1,15 +0,0 @@
-/**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
- */
-/**
- * Resolve Rust use-path to a file.
- * Handles crate::, super::, self:: prefixes and :: path separators.
- */
-export declare function resolveRustImport(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
-/**
- * Try to resolve a Rust module path to a file.
- * Tries: path.rs, path/mod.rs, and with the last segment stripped
- * (last segment might be a symbol name, not a module).
- */
-export declare function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null;

package/dist/core/ingestion/resolvers/rust.js

@@ -1,73 +0,0 @@
-/**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
- */
-/**
- * Resolve Rust use-path to a file.
- * Handles crate::, super::, self:: prefixes and :: path separators.
- */
-export function resolveRustImport(currentFile, importPath, allFiles) {
-    let rustPath;
-    if (importPath.startsWith('crate::')) {
-        // crate:: resolves from src/ directory (standard Rust layout)
-        rustPath = importPath.slice(7).replace(/::/g, '/');
-        // Try from src/ (standard layout)
-        const fromSrc = tryRustModulePath('src/' + rustPath, allFiles);
-        if (fromSrc)
-            return fromSrc;
-        // Try from repo root (non-standard)
-        const fromRoot = tryRustModulePath(rustPath, allFiles);
-        if (fromRoot)
-            return fromRoot;
-        return null;
-    }
-    if (importPath.startsWith('super::')) {
-        // super:: = parent directory of current file's module
-        const currentDir = currentFile.split('/').slice(0, -1);
-        currentDir.pop(); // Go up one level for super::
-        rustPath = importPath.slice(7).replace(/::/g, '/');
-        const fullPath = [...currentDir, rustPath].join('/');
-        return tryRustModulePath(fullPath, allFiles);
-    }
-    if (importPath.startsWith('self::')) {
-        // self:: = current module's directory
-        const currentDir = currentFile.split('/').slice(0, -1);
-        rustPath = importPath.slice(6).replace(/::/g, '/');
-        const fullPath = [...currentDir, rustPath].join('/');
-        return tryRustModulePath(fullPath, allFiles);
-    }
-    // Bare path without prefix (e.g., from a use in a nested module)
-    // Convert :: to / and try suffix matching
-    if (importPath.includes('::')) {
-        rustPath = importPath.replace(/::/g, '/');
-        return tryRustModulePath(rustPath, allFiles);
-    }
-    return null;
-}
-/**
- * Try to resolve a Rust module path to a file.
- * Tries: path.rs, path/mod.rs, and with the last segment stripped
- * (last segment might be a symbol name, not a module).
- */
-export function tryRustModulePath(modulePath, allFiles) {
-    // Try direct: path.rs
-    if (allFiles.has(modulePath + '.rs'))
-        return modulePath + '.rs';
-    // Try directory: path/mod.rs
-    if (allFiles.has(modulePath + '/mod.rs'))
-        return modulePath + '/mod.rs';
-    // Try path/lib.rs (for crate root)
-    if (allFiles.has(modulePath + '/lib.rs'))
-        return modulePath + '/lib.rs';
-    // The last segment might be a symbol (function, struct, etc.), not a module.
-    // Strip it and try again.
-    const lastSlash = modulePath.lastIndexOf('/');
-    if (lastSlash > 0) {
-        const parentPath = modulePath.substring(0, lastSlash);
-        if (allFiles.has(parentPath + '.rs'))
-            return parentPath + '.rs';
-        if (allFiles.has(parentPath + '/mod.rs'))
-            return parentPath + '/mod.rs';
-    }
-    return null;
-}

package/dist/core/ingestion/resolvers/standard.d.ts

@@ -1,28 +0,0 @@
-/**
- * Standard import path resolution.
- * Handles relative imports, path alias rewriting, and generic suffix matching.
- * Used as the fallback when language-specific resolvers don't match.
- */
-import type { SuffixIndex } from './utils.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-/** TypeScript path alias config parsed from tsconfig.json */
-export interface TsconfigPaths {
-    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
-    aliases: Map<string, string>;
-    /** Base URL for path resolution (relative to repo root) */
-    baseUrl: string;
-}
-/** Max entries in the resolve cache. Beyond this, entries are evicted.
- *  100K entries ≈ 15MB — covers the most common import patterns. */
-export declare const RESOLVE_CACHE_CAP = 100000;
-/**
- * Resolve an import path to a file path in the repository.
- *
- * Language-specific preprocessing is applied before the generic resolution:
- * - TypeScript/JavaScript: rewrites tsconfig path aliases
- * - Rust: converts crate::/super::/self:: to relative paths
- *
- * Java wildcards and Go package imports are handled separately in processImports
- * because they resolve to multiple files.
- */
-export declare const resolveImportPath: (currentFile: string, importPath: string, allFiles: Set<string>, allFileList: string[], normalizedFileList: string[], resolveCache: Map<string, string | null>, language: SupportedLanguages, tsconfigPaths: TsconfigPaths | null, index?: SuffixIndex) => string | null;

package/dist/core/ingestion/resolvers/standard.js

@@ -1,145 +0,0 @@
-/**
- * Standard import path resolution.
- * Handles relative imports, path alias rewriting, and generic suffix matching.
- * Used as the fallback when language-specific resolvers don't match.
- */
-import { tryResolveWithExtensions, suffixResolve } from './utils.js';
-import { resolveRustImport } from './rust.js';
-import { SupportedLanguages } from '../../../config/supported-languages.js';
-/** Max entries in the resolve cache. Beyond this, entries are evicted.
- *  100K entries ≈ 15MB — covers the most common import patterns. */
-export const RESOLVE_CACHE_CAP = 100_000;
-/**
- * Resolve an import path to a file path in the repository.
- *
- * Language-specific preprocessing is applied before the generic resolution:
- * - TypeScript/JavaScript: rewrites tsconfig path aliases
- * - Rust: converts crate::/super::/self:: to relative paths
- *
- * Java wildcards and Go package imports are handled separately in processImports
- * because they resolve to multiple files.
- */
-export const resolveImportPath = (currentFile, importPath, allFiles, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index) => {
-    const cacheKey = `${currentFile}::${importPath}`;
-    if (resolveCache.has(cacheKey))
-        return resolveCache.get(cacheKey) ?? null;
-    const cache = (result) => {
-        // Evict oldest 20% when cap is reached instead of clearing all
-        if (resolveCache.size >= RESOLVE_CACHE_CAP) {
-            const evictCount = Math.floor(RESOLVE_CACHE_CAP * 0.2);
-            const iter = resolveCache.keys();
-            for (let i = 0; i < evictCount; i++) {
-                const key = iter.next().value;
-                if (key !== undefined)
-                    resolveCache.delete(key);
-            }
-        }
-        resolveCache.set(cacheKey, result);
-        return result;
-    };
-    // ---- TypeScript/JavaScript: rewrite path aliases ----
-    if ((language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) &&
-        tsconfigPaths &&
-        !importPath.startsWith('.')) {
-        for (const [aliasPrefix, targetPrefix] of tsconfigPaths.aliases) {
-            if (importPath.startsWith(aliasPrefix)) {
-                const remainder = importPath.slice(aliasPrefix.length);
-                // Build the rewritten path relative to baseUrl
-                const rewritten = tsconfigPaths.baseUrl === '.'
-                    ? targetPrefix + remainder
-                    : tsconfigPaths.baseUrl + '/' + targetPrefix + remainder;
-                // Try direct resolution from repo root
-                const resolved = tryResolveWithExtensions(rewritten, allFiles);
-                if (resolved)
-                    return cache(resolved);
-                // Try suffix matching as fallback
-                const parts = rewritten.split('/').filter(Boolean);
-                const suffixResult = suffixResolve(parts, normalizedFileList, allFileList, index);
-                if (suffixResult)
-                    return cache(suffixResult);
-            }
-        }
-    }
-    // ---- Rust: convert module path syntax to file paths ----
-    if (language === SupportedLanguages.Rust) {
-        // Handle grouped imports: use crate::module::{Foo, Bar, Baz}
-        // Extract the prefix path before ::{...} and resolve the module, not the symbols
-        let rustImportPath = importPath;
-        const braceIdx = importPath.indexOf('::{');
-        if (braceIdx !== -1) {
-            rustImportPath = importPath.substring(0, braceIdx);
-        }
-        else if (importPath.startsWith('{') && importPath.endsWith('}')) {
-            // Top-level grouped imports: use {crate::a, crate::b}
-            // Iterate each part and return the first that resolves. This function returns a single
-            // string, so callers that need ALL edges must intercept before reaching here (see the
-            // Rust grouped-import blocks in processImports / processImportsBatch). This fallback
-            // handles any path that reaches resolveImportPath directly.
-            const inner = importPath.slice(1, -1);
-            const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
-            for (const part of parts) {
-                const partResult = resolveRustImport(currentFile, part, allFiles);
-                if (partResult)
-                    return cache(partResult);
-            }
-            return cache(null);
-        }
-        const rustResult = resolveRustImport(currentFile, rustImportPath, allFiles);
-        if (rustResult)
-            return cache(rustResult);
-        // Fall through to generic resolution if Rust-specific didn't match
-    }
-    // ---- Python relative imports (PEP 328): .module, ..module, ... ----
-    if (language === SupportedLanguages.Python && importPath.startsWith('.')) {
-        const dotMatch = importPath.match(/^(\.+)(.*)/);
-        if (dotMatch) {
-            const dotCount = dotMatch[1].length;
-            const modulePart = dotMatch[2]; // e.g., "models" from ".models"
-            const dirParts = currentFile.split('/').slice(0, -1); // remove filename
-            // Navigate up: 1 dot = same package, 2 dots = parent package, etc.
-            // First dot means "current package", each additional dot goes up one level
-            for (let i = 1; i < dotCount; i++) {
-                dirParts.pop();
-            }
-            if (modulePart) {
-                // from .models import User → resolve "models" relative to current package
-                const modulePath = modulePart.replace(/\./g, '/');
-                dirParts.push(...modulePath.split('/'));
-            }
-            const basePath = dirParts.join('/');
-            const resolved = tryResolveWithExtensions(basePath, allFiles);
-            return cache(resolved);
-        }
-    }
-    // ---- Generic relative import resolution (./ and ../) ----
-    const currentDir = currentFile.split('/').slice(0, -1);
-    const parts = importPath.split('/');
-    for (const part of parts) {
-        if (part === '.')
-            continue;
-        if (part === '..') {
-            currentDir.pop();
-        }
-        else {
-            currentDir.push(part);
-        }
-    }
-    const basePath = currentDir.join('/');
-    if (importPath.startsWith('.')) {
-        const resolved = tryResolveWithExtensions(basePath, allFiles);
-        return cache(resolved);
-    }
-    // ---- Generic package/absolute import resolution (suffix matching) ----
-    // Java wildcards are handled in processImports, not here
-    if (importPath.endsWith('.*')) {
-        return cache(null);
-    }
-    // C/C++ includes use actual file paths (e.g. "animal.h") — don't convert dots to slashes
-    const isCpp = language === SupportedLanguages.C || language === SupportedLanguages.CPlusPlus;
-    const pathLike = importPath.includes('/') || isCpp
-        ? importPath
-        : importPath.replace(/\./g, '/');
-    const pathParts = pathLike.split('/').filter(Boolean);
-    const resolved = suffixResolve(pathParts, normalizedFileList, allFileList, index);
-    return cache(resolved);
-};

package/dist/core/ingestion/resolvers/utils.d.ts

@@ -1,33 +0,0 @@
-/**
- * Shared utilities for import resolution.
- * Extracted from import-processor.ts to reduce file size.
- */
-/** All file extensions to try during resolution */
-export declare const EXTENSIONS: string[];
-/**
- * Try to match a path (with extensions) against the known file set.
- * Returns the matched file path or null.
- */
-export declare function tryResolveWithExtensions(basePath: string, allFiles: Set<string>): string | null;
-/**
- * Build a suffix index for O(1) endsWith lookups.
- * Maps every possible path suffix to its original file path.
- * e.g. for "src/com/example/Foo.java":
- *   "Foo.java" -> "src/com/example/Foo.java"
- *   "example/Foo.java" -> "src/com/example/Foo.java"
- *   "com/example/Foo.java" -> "src/com/example/Foo.java"
- *   etc.
- */
-export interface SuffixIndex {
-    /** Exact suffix lookup (case-sensitive) */
-    get(suffix: string): string | undefined;
-    /** Case-insensitive suffix lookup */
-    getInsensitive(suffix: string): string | undefined;
-    /** Get all files in a directory suffix */
-    getFilesInDir(dirSuffix: string, extension: string): string[];
-}
-export declare function buildSuffixIndex(normalizedFileList: string[], allFileList: string[]): SuffixIndex;
-/**
- * Suffix-based resolution using index. O(1) per lookup instead of O(files).
- */
-export declare function suffixResolve(pathParts: string[], normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;

package/dist/core/ingestion/resolvers/utils.js

@@ -1,120 +0,0 @@
-/**
- * Shared utilities for import resolution.
- * Extracted from import-processor.ts to reduce file size.
- */
-/** All file extensions to try during resolution */
-export const EXTENSIONS = [
-    '',
-    // TypeScript/JavaScript
-    '.tsx', '.ts', '.jsx', '.js', '/index.tsx', '/index.ts', '/index.jsx', '/index.js',
-    // Python
-    '.py', '/__init__.py',
-    // Java
-    '.java',
-    // Kotlin
-    '.kt', '.kts',
-    // C/C++
-    '.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.hh',
-    // C#
-    '.cs',
-    // Go
-    '.go',
-    // Rust
-    '.rs', '/mod.rs',
-    // PHP
-    '.php', '.phtml',
-    // Swift
-    '.swift',
-];
-/**
- * Try to match a path (with extensions) against the known file set.
- * Returns the matched file path or null.
- */
-export function tryResolveWithExtensions(basePath, allFiles) {
-    for (const ext of EXTENSIONS) {
-        const candidate = basePath + ext;
-        if (allFiles.has(candidate))
-            return candidate;
-    }
-    return null;
-}
-export function buildSuffixIndex(normalizedFileList, allFileList) {
-    // Map: normalized suffix -> original file path
-    const exactMap = new Map();
-    // Map: lowercase suffix -> original file path
-    const lowerMap = new Map();
-    // Map: directory suffix -> list of file paths in that directory
-    const dirMap = new Map();
-    for (let i = 0; i < normalizedFileList.length; i++) {
-        const normalized = normalizedFileList[i];
-        const original = allFileList[i];
-        const parts = normalized.split('/');
-        // Index all suffixes: "a/b/c.java" -> ["c.java", "b/c.java", "a/b/c.java"]
-        for (let j = parts.length - 1; j >= 0; j--) {
-            const suffix = parts.slice(j).join('/');
-            // Only store first match (longest path wins for ambiguous suffixes)
-            if (!exactMap.has(suffix)) {
-                exactMap.set(suffix, original);
-            }
-            const lower = suffix.toLowerCase();
-            if (!lowerMap.has(lower)) {
-                lowerMap.set(lower, original);
-            }
-        }
-        // Index directory membership
-        const lastSlash = normalized.lastIndexOf('/');
-        if (lastSlash >= 0) {
-            // Build all directory suffixes
-            const dirParts = parts.slice(0, -1);
-            const fileName = parts[parts.length - 1];
-            const ext = fileName.substring(fileName.lastIndexOf('.'));
-            for (let j = dirParts.length - 1; j >= 0; j--) {
-                const dirSuffix = dirParts.slice(j).join('/');
-                const key = `${dirSuffix}:${ext}`;
-                let list = dirMap.get(key);
-                if (!list) {
-                    list = [];
-                    dirMap.set(key, list);
-                }
-                list.push(original);
-            }
-        }
-    }
-    return {
-        get: (suffix) => exactMap.get(suffix),
-        getInsensitive: (suffix) => lowerMap.get(suffix.toLowerCase()),
-        getFilesInDir: (dirSuffix, extension) => {
-            return dirMap.get(`${dirSuffix}:${extension}`) || [];
-        },
-    };
-}
-/**
- * Suffix-based resolution using index. O(1) per lookup instead of O(files).
- */
-export function suffixResolve(pathParts, normalizedFileList, allFileList, index) {
-    if (index) {
-        for (let i = 0; i < pathParts.length; i++) {
-            const suffix = pathParts.slice(i).join('/');
-            for (const ext of EXTENSIONS) {
-                const suffixWithExt = suffix + ext;
-                const result = index.get(suffixWithExt) || index.getInsensitive(suffixWithExt);
-                if (result)
-                    return result;
-            }
-        }
-        return null;
-    }
-    // Fallback: linear scan (for backward compatibility)
-    for (let i = 0; i < pathParts.length; i++) {
-        const suffix = pathParts.slice(i).join('/');
-        for (const ext of EXTENSIONS) {
-            const suffixWithExt = suffix + ext;
-            const suffixPattern = '/' + suffixWithExt;
-            const matchIdx = normalizedFileList.findIndex(filePath => filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
-            if (matchIdx !== -1) {
-                return allFileList[matchIdx];
-            }
-        }
-    }
-    return null;
-}

package/dist/core/ingestion/symbol-resolver.d.ts

@@ -1,32 +0,0 @@
-/**
- * Symbol Resolver
- *
- * Import-filtered candidate narrowing for bare identifier resolution.
- * NOT FQN resolution — does not parse qualifiers (ns::Bar, com.foo.Bar).
- *
- * Shared between heritage-processor.ts and call-processor.ts.
- */
-import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
-import type { ImportMap, PackageMap, NamedImportMap } from './import-processor.js';
-/** Resolution tier for internal tracking, logging, and test assertions. */
-export type ResolutionTier = 'same-file' | 'import-scoped' | 'unique-global';
-/** Internal resolution result preserving tier metadata. */
-export interface InternalResolution {
-    definition: SymbolDefinition;
-    tier: ResolutionTier;
-    candidateCount: number;
-}
-/**
- * Resolve a bare identifier to its best-matching definition using import context.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactFull — authoritative)
- * 2. Import-scoped (lookupFuzzy filtered by importMap — acceptable)
- * 3. Unique global (lookupFuzzy with exactly 1 match — acceptable fallback)
- *
- * If multiple global candidates remain after filtering, returns null.
- * A wrong edge is worse than no edge.
- */
-export declare const resolveSymbol: (name: string, currentFilePath: string, symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, namedImportMap?: NamedImportMap) => SymbolDefinition | null;
-/** Internal resolver preserving tier metadata for logging and test assertions. */
-export declare const resolveSymbolInternal: (name: string, currentFilePath: string, symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, namedImportMap?: NamedImportMap) => InternalResolution | null;