gitnexus 1.4.6 → 1.4.8

package/dist/core/ingestion/import-processor.js

@@ -3,12 +3,11 @@ import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/pa
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
 import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { extractNamedBindings } from './named-binding-extraction.js';
 import { getTreeSitterBufferSize } from './constants.js';
-import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
-import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, resolvePythonImport, } from './resolvers/index.js';
+import { loadImportConfigs } from './language-config.js';
+import { buildSuffixIndex } from './resolvers/index.js';
 import { callRouters } from './call-routing.js';
+import { importResolvers, namedBindingExtractors, preprocessImportPath } from './import-resolution.js';
 const isDev = process.env.NODE_ENV === 'development';
 /**
  * Check if a file path is directly inside a package directory identified by its suffix.
@@ -26,121 +25,36 @@ export function buildImportResolutionContext(allPaths) {
     const allFileList = allPaths;
     const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
     const allFilePaths = new Set(allFileList);
-    const suffixIndex = buildSuffixIndex(normalizedFileList, allFileList);
-    return { allFilePaths, allFileList, normalizedFileList, suffixIndex, resolveCache: new Map() };
+    const index = buildSuffixIndex(normalizedFileList, allFileList);
+    return { allFilePaths, allFileList, normalizedFileList, index, resolveCache: new Map() };
 }
-/**
- * Shared language dispatch for import resolution.
- * Used by both processImports and processImportsFromExtracted.
- */
-function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx) {
-    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = ctx;
-    const { tsconfigPaths, goModule, composerConfig, swiftPackageConfig, csharpConfigs } = configs;
-    // JVM languages (Java + Kotlin): handle wildcards and member imports
-    if (language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin) {
-        const exts = language === SupportedLanguages.Java ? ['.java'] : KOTLIN_EXTENSIONS;
-        if (rawImportPath.endsWith('.*')) {
-            const matchedFiles = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, exts, index);
-            if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) {
-                const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
-                if (javaMatches.length > 0)
-                    return { kind: 'files', files: javaMatches };
-            }
-            if (matchedFiles.length > 0)
-                return { kind: 'files', files: matchedFiles };
-            // Fall through to standard resolution
-        }
-        else {
-            let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index);
-            if (!memberResolved && language === SupportedLanguages.Kotlin) {
-                memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
-            }
-            if (memberResolved)
-                return { kind: 'files', files: [memberResolved] };
-            // Fall through to standard resolution
-        }
-    }
-    // Go: handle package-level imports
-    if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) {
-        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
-        if (pkgSuffix) {
-            const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList);
-            if (pkgFiles.length > 0) {
-                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
-            }
-        }
-        // Fall through if no files found (package might be external)
-    }
-    // C#: handle namespace-based imports (using directives)
-    if (language === SupportedLanguages.CSharp && csharpConfigs.length > 0) {
-        const resolvedFiles = resolveCSharpImport(rawImportPath, csharpConfigs, normalizedFileList, allFileList, index);
-        if (resolvedFiles.length > 1) {
-            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
-            if (dirSuffix) {
-                return { kind: 'package', files: resolvedFiles, dirSuffix };
-            }
-        }
-        if (resolvedFiles.length > 0)
-            return { kind: 'files', files: resolvedFiles };
-        return null;
-    }
-    // PHP: handle namespace-based imports (use statements)
-    if (language === SupportedLanguages.PHP) {
-        const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index);
-        return resolved ? { kind: 'files', files: [resolved] } : null;
-    }
-    // Swift: handle module imports
-    if (language === SupportedLanguages.Swift && swiftPackageConfig) {
-        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
-        if (targetDir) {
-            const dirPrefix = targetDir + '/';
-            const files = [];
-            for (let i = 0; i < normalizedFileList.length; i++) {
-                if (normalizedFileList[i].startsWith(dirPrefix) && normalizedFileList[i].endsWith('.swift')) {
-                    files.push(allFileList[i]);
-                }
-            }
-            if (files.length > 0)
-                return { kind: 'files', files };
-        }
-        return null; // External framework (Foundation, UIKit, etc.)
-    }
-    // Python: relative imports (PEP 328) + proximity-based bare imports
-    // Falls through to standard suffix resolution when proximity finds no match.
-    if (language === SupportedLanguages.Python) {
-        const resolved = resolvePythonImport(filePath, rawImportPath, allFilePaths);
-        if (resolved)
-            return { kind: 'files', files: [resolved] };
-        if (rawImportPath.startsWith('.'))
-            return null; // relative but unresolved — don't suffix-match
-    }
-    // Ruby: require / require_relative
-    if (language === SupportedLanguages.Ruby) {
-        const resolved = resolveRubyImport(rawImportPath, normalizedFileList, allFileList, index);
-        return resolved ? { kind: 'files', files: [resolved] } : null;
-    }
-    // Rust: expand top-level grouped imports: use {crate::a, crate::b}
-    if (language === SupportedLanguages.Rust && rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
-        const inner = rawImportPath.slice(1, -1);
-        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
-        const resolved = [];
-        for (const part of parts) {
-            const r = resolveRustImport(filePath, part, allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
-    }
-    // Standard single-file resolution
-    const resolvedPath = resolveImportPath(filePath, rawImportPath, allFilePaths, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index);
-    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+// Config loaders extracted to ./language-config.ts (Phase 2 refactor)
+// Resolver dispatch tables are in ./import-resolution.ts — imported above
+/** Create IMPORTS edge helpers that share a resolved-count tracker. */
+function createImportEdgeHelpers(graph, importMap) {
+    let totalImportsResolved = 0;
+    const addImportGraphEdge = (filePath, resolvedPath) => {
+        const sourceId = generateId('File', filePath);
+        const targetId = generateId('File', resolvedPath);
+        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        totalImportsResolved++;
+        graph.addRelationship({ id: relId, sourceId, targetId, type: 'IMPORTS', confidence: 1.0, reason: '' });
+    };
+    const addImportEdge = (filePath, resolvedPath) => {
+        addImportGraphEdge(filePath, resolvedPath);
+        if (!importMap.has(filePath))
+            importMap.set(filePath, new Set());
+        importMap.get(filePath).add(resolvedPath);
+    };
+    return { addImportEdge, addImportGraphEdge, getResolvedCount: () => totalImportsResolved };
 }
 /**
  * Apply an ImportResult: emit graph edges and update ImportMap/PackageMap.
  * If namedBindings are provided and the import resolves to a single file,
  * also populate the NamedImportMap for precise Tier 2a resolution.
+ * Bindings tagged with `isModuleAlias` are routed to moduleAliasMap instead.
  */
-function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
+function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap, moduleAliasMap) {
     if (!result)
         return;
     if (result.kind === 'package' && packageMap) {
@@ -158,14 +72,66 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
         for (const resolvedFile of files) {
             addImportEdge(filePath, resolvedFile);
         }
-        // Record named bindings for precise Tier 2a resolution
-        if (namedBindings && namedImportMap && files.length === 1) {
+        // Route module aliases (import X as Y) directly to moduleAliasMap.
+        // These are module-level aliases, not symbol bindings — they don't belong in namedImportMap.
+        if (namedBindings && moduleAliasMap && files.length === 1) {
             const resolvedFile = files[0];
+            for (const binding of namedBindings) {
+                if (!binding.isModuleAlias)
+                    continue;
+                let aliasMap = moduleAliasMap.get(filePath);
+                if (!aliasMap) {
+                    aliasMap = new Map();
+                    moduleAliasMap.set(filePath, aliasMap);
+                }
+                aliasMap.set(binding.local, resolvedFile);
+            }
+        }
+        // Record named bindings for precise Tier 2a resolution.
+        // If the same local name is imported from multiple files (e.g., Java static imports
+        // of overloaded methods), remove the entry so resolution falls through to Tier 2a
+        // import-scoped which sees all candidates and can apply arity narrowing.
+        if (namedBindings && namedImportMap) {
             if (!namedImportMap.has(filePath))
                 namedImportMap.set(filePath, new Map());
             const fileBindings = namedImportMap.get(filePath);
-            for (const binding of namedBindings) {
-                fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+            if (files.length === 1) {
+                const resolvedFile = files[0];
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue; // already routed to moduleAliasMap
+                    const existing = fileBindings.get(binding.local);
+                    if (existing && existing.sourcePath !== resolvedFile) {
+                        fileBindings.delete(binding.local);
+                    }
+                    else {
+                        fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+                    }
+                }
+            }
+            else {
+                // Multi-file resolution (e.g., Rust `use crate::models::{User, Repo}`).
+                // Match each binding to a resolved file by comparing the lowercase binding name
+                // to the file's basename (without extension). If no match, skip the binding.
+                for (const binding of namedBindings) {
+                    if (binding.isModuleAlias)
+                        continue;
+                    const lowerName = binding.exported.toLowerCase();
+                    const matchedFile = files.find(f => {
+                        const base = f.replace(/\\/g, '/').split('/').pop() ?? '';
+                        const nameWithoutExt = base.substring(0, base.lastIndexOf('.')).toLowerCase();
+                        return nameWithoutExt === lowerName;
+                    });
+                    if (matchedFile) {
+                        const existing = fileBindings.get(binding.local);
+                        if (existing && existing.sourcePath !== matchedFile) {
+                            fileBindings.delete(binding.local);
+                        }
+                        else {
+                            fileBindings.set(binding.local, { sourcePath: matchedFile, exportedName: binding.exported });
+                        }
+                    }
+                }
             }
         }
     }
@@ -177,6 +143,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
     // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files
     const allFileList = allPaths ?? files.map(f => f.path);
     const allFilePaths = new Set(allFileList);
@@ -190,40 +157,10 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
     const index = buildSuffixIndex(normalizedFileList, allFileList);
     // Track import statistics
     let totalImportsFound = 0;
-    let totalImportsResolved = 0;
     // Load language-specific configs once before the file loop
-    const effectiveRoot = repoRoot || '';
-    const configs = {
-        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
-        goModule: await loadGoModulePath(effectiveRoot),
-        composerConfig: await loadComposerConfig(effectiveRoot),
-        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
-        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
-    };
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
-    // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
-    const addImportGraphEdge = (filePath, resolvedPath) => {
-        const sourceId = generateId('File', filePath);
-        const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
-        totalImportsResolved++;
-        graph.addRelationship({
-            id: relId,
-            sourceId,
-            targetId,
-            type: 'IMPORTS',
-            confidence: 1.0,
-            reason: '',
-        });
-    };
-    // Helper: add an IMPORTS edge + update import map
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
-        if (!importMap.has(filePath)) {
-            importMap.set(filePath, new Set());
-        }
-        importMap.get(filePath).add(resolvedPath);
-    };
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onProgress?.(i + 1, files.length);
@@ -291,14 +228,14 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
                     }
                     return;
                 }
-                // Clean path (remove quotes and angle brackets for C/C++ includes)
-                const rawImportPath = language === SupportedLanguages.Kotlin
-                    ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import'])
-                    : sourceNode.text.replace(/['"<>]/g, '');
+                const rawImportPath = preprocessImportPath(sourceNode.text, captureMap['import'], language);
+                if (!rawImportPath)
+                    return;
                 totalImportsFound++;
-                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, resolveCtx);
-                const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined;
-                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap);
+                const result = importResolvers[language](rawImportPath, file.path, resolveCtx);
+                const extractor = namedBindingExtractors[language];
+                const bindings = namedImportMap && extractor ? extractor(captureMap['import']) : undefined;
+                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap, moduleAliasMap);
             }
             // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
             if (captureMap['call']) {
@@ -308,7 +245,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
                     const routed = callRouter(callNameNode.text, captureMap['call']);
                     if (routed && routed.kind === 'import') {
                         totalImportsFound++;
-                        const result = resolveLanguageImport(file.path, routed.importPath, language, configs, resolveCtx);
+                        const result = importResolvers[language](routed.importPath, file.path, resolveCtx);
                         applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
                     }
                 }
@@ -322,7 +259,7 @@ export const processImports = async (graph, files, astCache, ctx, onProgress, re
         }
     }
     if (isDev) {
-        console.log(`📊 Import processing complete: ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+        console.log(`📊 Import processing complete: ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
     }
 };
 // ============================================================================
@@ -332,41 +269,13 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
     const importMap = ctx.importMap;
     const packageMap = ctx.packageMap;
     const namedImportMap = ctx.namedImportMap;
+    const moduleAliasMap = ctx.moduleAliasMap;
     const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
-    const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = importCtx;
+    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = importCtx;
     let totalImportsFound = 0;
-    let totalImportsResolved = 0;
-    const effectiveRoot = repoRoot || '';
-    const configs = {
-        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
-        goModule: await loadGoModulePath(effectiveRoot),
-        composerConfig: await loadComposerConfig(effectiveRoot),
-        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
-        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
-    };
-    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
-    // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
-    const addImportGraphEdge = (filePath, resolvedPath) => {
-        const sourceId = generateId('File', filePath);
-        const targetId = generateId('File', resolvedPath);
-        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
-        totalImportsResolved++;
-        graph.addRelationship({
-            id: relId,
-            sourceId,
-            targetId,
-            type: 'IMPORTS',
-            confidence: 1.0,
-            reason: '',
-        });
-    };
-    const addImportEdge = (filePath, resolvedPath) => {
-        addImportGraphEdge(filePath, resolvedPath);
-        if (!importMap.has(filePath)) {
-            importMap.set(filePath, new Set());
-        }
-        importMap.get(filePath).add(resolvedPath);
-    };
+    const configs = await loadImportConfigs(repoRoot || '');
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache, configs };
+    const { addImportEdge, addImportGraphEdge, getResolvedCount } = createImportEdgeHelpers(graph, importMap);
     // Group by file for progress reporting (users see file count, not import count)
     const importsByFile = new Map();
     for (const imp of extractedImports) {
@@ -387,12 +296,12 @@ export const processImportsFromExtracted = async (graph, files, extractedImports
         }
         for (const imp of fileImports) {
             totalImportsFound++;
-            const result = resolveLanguageImport(filePath, imp.rawImportPath, imp.language, configs, resolveCtx);
-            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap);
+            const result = importResolvers[imp.language](imp.rawImportPath, filePath, resolveCtx);
+            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap, moduleAliasMap);
         }
     }
     onProgress?.(totalFiles, totalFiles);
     if (isDev) {
-        console.log(`📊 Import processing (fast path): ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+        console.log(`📊 Import processing (fast path): ${getResolvedCount()}/${totalImportsFound} imports resolved to graph edges`);
     }
 };

package/dist/core/ingestion/import-resolution.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Import Resolution Dispatch
+ *
+ * Per-language dispatch table for import resolution and named binding extraction.
+ * Replaces the 120-line if-chain in resolveLanguageImport() and the 7-branch
+ * dispatch in extractNamedBindings() with a single table lookup each.
+ *
+ * Follows the existing ExportChecker / CallRouter pattern:
+ *   - Function aliases (not interfaces) to avoid megamorphic inline-cache issues
+ *   - `satisfies Record<SupportedLanguages, ...>` for compile-time exhaustiveness
+ *   - Const dispatch table — configs are accessed via ctx.configs at call time
+ */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import type { SyntaxNode } from './utils.js';
+import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from './resolvers/index.js';
+import type { SwiftPackageConfig } from './language-config.js';
+import { extractTsNamedBindings, extractPythonNamedBindings, extractKotlinNamedBindings, extractRustNamedBindings, extractPhpNamedBindings, extractCsharpNamedBindings, extractJavaNamedBindings } from './named-binding-extraction.js';
+import type { ImportResolutionContext } from './import-processor.js';
+/**
+ * Result of resolving an import via language-specific dispatch.
+ * - 'files': resolved to one or more files -> add to ImportMap
+ * - 'package': resolved to a directory -> add graph edges + store dirSuffix in PackageMap
+ * - null: no resolution (external dependency, etc.)
+ */
+export type ImportResult = {
+    kind: 'files';
+    files: string[];
+} | {
+    kind: 'package';
+    files: string[];
+    dirSuffix: string;
+} | null;
+/** Bundled language-specific configs loaded once per ingestion run. */
+export interface ImportConfigs {
+    tsconfigPaths: TsconfigPaths | null;
+    goModule: GoModuleConfig | null;
+    composerConfig: ComposerConfig | null;
+    swiftPackageConfig: SwiftPackageConfig | null;
+    csharpConfigs: CSharpProjectConfig[];
+}
+/** Full context for import resolution: file lookups + language configs. */
+export interface ResolveCtx extends ImportResolutionContext {
+    configs: ImportConfigs;
+}
+/** Per-language import resolver -- function alias matching ExportChecker/CallRouter pattern. */
+export type ImportResolverFn = (rawImportPath: string, filePath: string, resolveCtx: ResolveCtx) => ImportResult;
+/** A single named import binding: local name in the importing file and exported name from the source.
+ *  When `isModuleAlias` is true, the binding represents a Python `import X as Y` module alias
+ *  and is routed to moduleAliasMap instead of namedImportMap during import processing. */
+export interface NamedBinding {
+    local: string;
+    exported: string;
+    isModuleAlias?: boolean;
+}
+/**
+ * Clean and preprocess a raw import source text into a resolved import path.
+ * Strips quotes/angle brackets (universal) and applies language-specific
+ * transformations (currently only Kotlin wildcard import detection).
+ */
+export declare function preprocessImportPath(sourceText: string, importNode: SyntaxNode, language: SupportedLanguages): string | null;
+/**
+ * Per-language import resolver dispatch table.
+ * Configs are accessed via ctx.configs at call time — no factory closure needed.
+ * Each resolver encapsulates the full resolution flow for its language, including
+ * fallthrough to standard resolution where appropriate.
+ */
+export declare const importResolvers: {
+    javascript: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    typescript: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    python: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    java: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    c: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    cpp: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    csharp: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    go: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    ruby: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    rust: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    php: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    kotlin: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+    swift: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
+};
+/**
+ * Per-language named binding extractor dispatch table.
+ * Languages with whole-module import semantics (Go, Ruby, C/C++, Swift) return undefined --
+ * their bindings are synthesized post-parse by synthesizeWildcardImportBindings() in pipeline.ts.
+ */
+export declare const namedBindingExtractors: {
+    javascript: typeof extractTsNamedBindings;
+    typescript: typeof extractTsNamedBindings;
+    python: typeof extractPythonNamedBindings;
+    java: typeof extractJavaNamedBindings;
+    c: any;
+    cpp: any;
+    csharp: typeof extractCsharpNamedBindings;
+    go: any;
+    ruby: any;
+    rust: typeof extractRustNamedBindings;
+    php: typeof extractPhpNamedBindings;
+    kotlin: typeof extractKotlinNamedBindings;
+    swift: any;
+};