gitnexus 1.6.6-rc.98 → 1.6.6

package/dist/core/ingestion/model/resolution-context.js

@@ -1,337 +0,0 @@
-/**
- * Resolution Context
- *
- * Single implementation of tiered name resolution.
- *
- * Resolution tiers (highest confidence first):
- * 1. Same file (lookupExactAll — authoritative)
- * 2a-named. Named binding chain (walkBindingChain via NamedImportMap)
- * 2a. Import-scoped (iterate importedFiles with lookupExactAll per file)
- * 2b. Package-scoped (iterate indexed files matching package dir with lookupExactAll)
- * 3. Global (lookupClassByName + lookupImplByName + lookupCallableByName — consumers must check count)
- *
- * Each tier queries the minimum necessary scope directly:
- * - Tier 2a iterates the caller's import set (O(imports) × O(1) lookupExactAll).
- * - Tier 2b iterates all indexed files filtered by package dir
- *   (O(files) × O(1) lookupExactAll — avoids a global name scan).
- * - Tier 3 combines lookupClassByName + lookupImplByName + lookupCallableByName
- *   (three O(1) index lookups with a narrow, type-specific result set).
- */
-import { createSemanticModel } from './semantic-model.js';
-/**
- * Check if a file path is directly inside a package directory identified by
- * its suffix. Used by Tier 2b package-scoped resolution (Go / C#).
- */
-export function isFileInPackageDir(filePath, dirSuffix) {
-    // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
-    const normalized = '/' + filePath.replace(/\\/g, '/');
-    if (!normalized.includes(dirSuffix))
-        return false;
-    const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length);
-    return !afterDir.includes('/');
-}
-/** Maximum re-export hops walkBindingChain will follow before giving up.
- *  A hard cap is needed to defend against pathological cycles that slip
- *  past the `visited` Set (e.g. a binding chain whose key is equal by
- *  string value but visits distinct modules). Five hops covers the
- *  common TypeScript monorepo pattern (component → pkg/index →
- *  packages/index → root/index → types/index). Chains longer than this
- *  fall through to Tier 2a-import / Tier 2b / Tier 3 resolution, which
- *  is a silent false-negative that the caller may or may not recover
- *  from. If a real repo hits this limit, raise it — there is no
- *  correctness reason to keep it at exactly 5. */
-const MAX_BINDING_CHAIN_DEPTH = 5;
-/**
- * Walk a named-binding re-export chain through NamedImportMap.
- *
- * When file A imports { User } from B, and B re-exports { User } from C,
- * the NamedImportMap for A points to B, but B has no User definition.
- * This function follows the chain: A → B → C until a definition is found.
- *
- * Returns the definitions found at the end of the chain, or null if the
- * chain breaks (missing binding, circular reference, or
- * {@link MAX_BINDING_CHAIN_DEPTH} exceeded). Internal to
- * resolution-context — not exported from the model barrel.
- */
-function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap) {
-    // Fast exit: most files have no named imports at all. Skip the Set
-    // allocation + loop entry on the common empty-binding path so resolve()
-    // stays allocation-free for the typical call site.
-    const firstBindings = namedImportMap.get(currentFilePath);
-    if (!firstBindings)
-        return null;
-    const firstBinding = firstBindings.get(name);
-    if (!firstBinding)
-        return null;
-    let lookupFile = currentFilePath;
-    let lookupName = name;
-    const visited = new Set();
-    for (let depth = 0; depth < MAX_BINDING_CHAIN_DEPTH; depth++) {
-        const bindings = depth === 0 ? firstBindings : namedImportMap.get(lookupFile);
-        if (!bindings)
-            return null;
-        const binding = depth === 0 ? firstBinding : bindings.get(lookupName);
-        if (!binding)
-            return null;
-        const key = `${binding.sourcePath}:${binding.exportedName}`;
-        if (visited.has(key))
-            return null; // circular
-        visited.add(key);
-        const targetName = binding.exportedName;
-        const resolvedDefs = symbolTable.lookupExactAll(binding.sourcePath, targetName);
-        if (resolvedDefs.length > 0)
-            return resolvedDefs;
-        // No definition in source file → follow re-export chain
-        lookupFile = binding.sourcePath;
-        lookupName = targetName;
-    }
-    return null;
-}
-/** Confidence scores per resolution tier. */
-export const TIER_CONFIDENCE = {
-    'same-file': 0.95,
-    'import-scoped': 0.9,
-    global: 0.5,
-};
-export const createResolutionContext = () => {
-    const model = createSemanticModel();
-    const symbols = model.symbols;
-    const importMap = new Map();
-    const packageMap = new Map();
-    const namedImportMap = new Map();
-    const moduleAliasMap = new Map();
-    // Inverted index: packageDirSuffix → Set<filePath>.
-    // Built lazily on first Tier 2b hit — one-time cost of O(totalFiles ×
-    // allUniqueDirSuffixes) isFileInPackageDir calls across the entire
-    // packageMap, amortized over the pipeline run. Subsequent Tier 2b
-    // resolutions are O(callerPackages × filesInPackage × O(1)).
-    let packageDirIndex = null;
-    // Per-file cache state
-    let cacheFile = null;
-    let cache = null;
-    let cacheHits = 0;
-    let cacheMisses = 0;
-    // Tier hit counters — replaces the lost fuzzyCallCount diagnostic
-    let tierSameFile = 0;
-    let tierImportScoped = 0;
-    let tierGlobal = 0;
-    let tierMiss = 0;
-    // --- Core resolution (single implementation of tier logic) ---
-    const resolveUncached = (name, fromFile) => {
-        // Tier 1: Same file — authoritative match (returns all overloads)
-        const localDefs = symbols.lookupExactAll(fromFile, name);
-        if (localDefs.length > 0) {
-            tierSameFile++;
-            return { candidates: localDefs, tier: 'same-file' };
-        }
-        // Tier 2a-named: Named binding chain (aliased / re-exported imports)
-        // Checked before import-scoped so that `import { User as U }` resolves
-        // correctly even when lookupExactAll on the alias name returns nothing.
-        const chainResult = walkBindingChain(name, fromFile, symbols, namedImportMap);
-        if (chainResult && chainResult.length > 0) {
-            tierImportScoped++;
-            return { candidates: chainResult, tier: 'import-scoped' };
-        }
-        // Tier 2a: Import-scoped — iterate the caller's imported files directly.
-        // O(importedFiles) × O(1) lookupExactAll — no global name scan needed.
-        const importedFiles = importMap.get(fromFile);
-        if (importedFiles) {
-            const importedDefs = [];
-            for (const file of importedFiles) {
-                importedDefs.push(...symbols.lookupExactAll(file, name));
-            }
-            if (importedDefs.length > 0) {
-                tierImportScoped++;
-                return { candidates: importedDefs, tier: 'import-scoped' };
-            }
-        }
-        // Tier 2b: Package-scoped — look up files in the caller's imported package
-        // directories via an inverted index (packageDirSuffix → Set<filePath>),
-        // then do O(1) lookupExactAll per file. The inverted index is built lazily
-        // on first Tier 2b hit by scanning symbols.getFiles() once, making
-        // subsequent Tier 2b resolutions O(packages × filesInPackage) instead of
-        // O(allFiles × packages).
-        const importedPackages = packageMap.get(fromFile);
-        if (importedPackages) {
-            // Lazily build the inverted index on first use. For each indexed file,
-            // test it against isFileInPackageDir for all known dirSuffixes collected
-            // from packageMap. This scans all files once (instead of per-resolution)
-            // and produces a dirSuffix → Set<filePath> map.
-            if (!packageDirIndex) {
-                // Collect all unique dir suffixes across the entire packageMap
-                const allDirSuffixes = new Set();
-                for (const dirs of packageMap.values()) {
-                    for (const d of dirs)
-                        allDirSuffixes.add(d);
-                }
-                packageDirIndex = new Map();
-                for (const file of symbols.getFiles()) {
-                    for (const dirSuffix of allDirSuffixes) {
-                        if (isFileInPackageDir(file, dirSuffix)) {
-                            let files = packageDirIndex.get(dirSuffix);
-                            if (!files) {
-                                files = new Set();
-                                packageDirIndex.set(dirSuffix, files);
-                            }
-                            files.add(file);
-                        }
-                    }
-                }
-            }
-            const packageDefs = [];
-            for (const dirSuffix of importedPackages) {
-                const filesInDir = packageDirIndex.get(dirSuffix);
-                if (filesInDir) {
-                    for (const file of filesInDir) {
-                        packageDefs.push(...symbols.lookupExactAll(file, name));
-                    }
-                }
-            }
-            if (packageDefs.length > 0) {
-                tierImportScoped++;
-                return { candidates: packageDefs, tier: 'import-scoped' };
-            }
-        }
-        // Tier 3: Global — targeted O(1) index lookups for each symbol category.
-        // Class-like symbols (Class, Struct, Interface, Enum, Record, Trait) are
-        // covered by lookupClassByName; Rust impl blocks by lookupImplByName
-        // (separate to avoid polluting heritage resolution); free callables
-        // (Function, Macro, Delegate) by lookupCallableByName; owner-scoped
-        // methods and constructors by `model.methods.lookupMethodByName`.
-        //
-        // FREE_CALLABLE_TYPES excludes Method/Constructor, so strictly-labeled
-        // methods are disjoint between the two indexes.
-        //
-        // Partial-state caveat: Python/Rust/Kotlin class methods are emitted
-        // as Function + ownerId — `rawSymbols.add` routes them through both
-        // the Function callable index AND, via the dispatch-key normalization
-        // in `wrappedAdd`, the method registry. The same `SymbolDefinition`
-        // reference lands in both `callableDefs` and `methodDefs`, so the
-        // Set-based dedup below is required.
-        //
-        // Known exclusion: TypeAlias, Const, and Variable are NOT reachable at
-        // Tier 3 — they don't belong to any of the indexes. TypeAlias is not
-        // a call target; Const/Variable are resolved via import or same-file
-        // tiers. Macro (C/C++) and Delegate (C#) stay in the callable index
-        // since call-processor.ts treats them as callable targets.
-        const classDefs = model.types.lookupClassByName(name);
-        const implDefs = model.types.lookupImplByName(name);
-        const callableDefs = symbols.lookupCallableByName(name);
-        const methodDefs = model.methods.lookupMethodByName(name);
-        if (classDefs.length === 0 &&
-            implDefs.length === 0 &&
-            callableDefs.length === 0 &&
-            methodDefs.length === 0) {
-            tierMiss++;
-            return null;
-        }
-        // Fast path: if no `Function + ownerId` class method was ever
-        // registered into the method registry (the only source of
-        // cross-index duplication), the callable and method indexes are
-        // guaranteed disjoint and we can concat without dedup.
-        if (!model.methods.hasFunctionMethods) {
-            const globalDefs = [
-                ...classDefs,
-                ...implDefs,
-                ...callableDefs,
-                ...methodDefs,
-            ];
-            tierGlobal++;
-            return { candidates: globalDefs, tier: 'global' };
-        }
-        // Slow path: dedup by nodeId because the same SymbolDefinition
-        // reference can land in both `callableDefs` (via the Function
-        // callable-index gate) and `methodDefs` (via the dispatch-key
-        // normalization routing Function+ownerId into MethodRegistry).
-        // Dedup covers all four index reads so any nodeId overlap (even
-        // theoretical ones between classDefs/implDefs) is caught.
-        const globalDefs = [];
-        const seen = new Set();
-        const pushUnique = (pool) => {
-            for (const def of pool) {
-                if (seen.has(def.nodeId))
-                    continue;
-                seen.add(def.nodeId);
-                globalDefs.push(def);
-            }
-        };
-        pushUnique(classDefs);
-        pushUnique(implDefs);
-        pushUnique(callableDefs);
-        pushUnique(methodDefs);
-        tierGlobal++;
-        return { candidates: globalDefs, tier: 'global' };
-    };
-    const resolve = (name, fromFile) => {
-        // Check cache (only when enabled AND fromFile matches cached file)
-        if (cache && cacheFile === fromFile) {
-            if (cache.has(name)) {
-                cacheHits++;
-                return cache.get(name);
-            }
-            cacheMisses++;
-        }
-        const result = resolveUncached(name, fromFile);
-        // Store in cache if active and file matches
-        if (cache && cacheFile === fromFile) {
-            cache.set(name, result);
-        }
-        return result;
-    };
-    // --- Cache lifecycle ---
-    const enableCache = (filePath) => {
-        cacheFile = filePath;
-        if (!cache)
-            cache = new Map();
-        else
-            cache.clear();
-    };
-    const clearCache = () => {
-        cacheFile = null;
-        // Reuse the Map instance — just clear entries to reduce GC pressure at scale.
-        cache?.clear();
-        // Note: packageDirIndex is NOT invalidated here. It is built lazily on
-        // first Tier 2b hit and remains valid across file boundaries because
-        // packageMap and the symbol file set are append-only during the calls
-        // phase (all parsing/import processing completes before resolution).
-        // Invalidating per-file would destroy the amortization benefit — the
-        // O(files × dirs) rebuild would run per-file instead of once.
-        // Full invalidation happens in clear() (pipeline reset).
-    };
-    const getStats = () => ({
-        ...symbols.getStats(),
-        cacheHits,
-        cacheMisses,
-        tierSameFile,
-        tierImportScoped,
-        tierGlobal,
-        tierMiss,
-    });
-    const clear = () => {
-        model.clear();
-        importMap.clear();
-        packageMap.clear();
-        namedImportMap.clear();
-        moduleAliasMap.clear();
-        packageDirIndex = null; // invalidate — will rebuild on next Tier 2b hit
-        clearCache();
-        cacheHits = 0;
-        cacheMisses = 0;
-        tierSameFile = 0;
-        tierImportScoped = 0;
-        tierGlobal = 0;
-        tierMiss = 0;
-    };
-    return {
-        resolve,
-        model,
-        importMap,
-        packageMap,
-        namedImportMap,
-        moduleAliasMap,
-        enableCache,
-        clearCache,
-        getStats,
-        clear,
-    };
-};

package/dist/core/ingestion/named-bindings/csharp.d.ts

@@ -1,3 +0,0 @@
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractCSharpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/csharp.js

@@ -1,37 +0,0 @@
-export function extractCSharpNamedBindings(importNode) {
-    // using_directive — three forms:
-    //   using Alias = NS.Type;          → aliasIdent + qualifiedName
-    //   using static NS.Type;           → static + qualifiedName (no alias)
-    //   using NS;                       → qualifiedName only (namespace, not capturable)
-    if (importNode.type !== 'using_directive')
-        return undefined;
-    let aliasIdent = null;
-    let qualifiedName = null;
-    let isStatic = false;
-    for (let i = 0; i < importNode.childCount; i++) {
-        const child = importNode.child(i);
-        if (child?.text === 'static')
-            isStatic = true;
-    }
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'identifier' && !aliasIdent)
-            aliasIdent = child;
-        else if (child?.type === 'qualified_name')
-            qualifiedName = child;
-    }
-    // Form 1: using Alias = NS.Type;
-    if (aliasIdent && qualifiedName) {
-        const fullText = qualifiedName.text;
-        const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-        return [{ local: aliasIdent.text, exported: exportedName }];
-    }
-    // Form 2: using static NS.Type; — last segment is the class name
-    if (isStatic && qualifiedName) {
-        const fullText = qualifiedName.text;
-        const lastSegment = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-        return [{ local: lastSegment, exported: lastSegment }];
-    }
-    // Form 3: using NS; — namespace import, can't resolve to per-symbol bindings
-    return undefined;
-}

package/dist/core/ingestion/named-bindings/java.d.ts

@@ -1,3 +0,0 @@
-import { type SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractJavaNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/java.js

@@ -1,29 +0,0 @@
-import { findChild } from '../utils/ast-helpers.js';
-export function extractJavaNamedBindings(importNode) {
-    // import_declaration > scoped_identifier "com.example.models.User"
-    // Wildcard imports (.*) don't produce named bindings
-    if (importNode.type !== 'import_declaration')
-        return undefined;
-    // Check for asterisk (wildcard import) and static modifier
-    let isStatic = false;
-    for (let i = 0; i < importNode.childCount; i++) {
-        const child = importNode.child(i);
-        if (child?.type === 'asterisk')
-            return undefined;
-        if (child?.text === 'static')
-            isStatic = true;
-    }
-    const scopedId = findChild(importNode, 'scoped_identifier');
-    if (!scopedId)
-        return undefined;
-    const fullText = scopedId.text;
-    const lastDot = fullText.lastIndexOf('.');
-    if (lastDot === -1)
-        return undefined;
-    const name = fullText.slice(lastDot + 1);
-    // Non-static: skip lowercase names — those are package imports, not class imports.
-    // Static: allow lowercase — `import static models.UserFactory.getUser` imports a method.
-    if (!isStatic && name[0] && name[0] === name[0].toLowerCase())
-        return undefined;
-    return [{ local: name, exported: name }];
-}

package/dist/core/ingestion/named-bindings/kotlin.d.ts

@@ -1,3 +0,0 @@
-import { type SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractKotlinNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/kotlin.js

@@ -1,36 +0,0 @@
-import { findChild } from '../utils/ast-helpers.js';
-export function extractKotlinNamedBindings(importNode) {
-    // import_header > identifier + import_alias > simple_identifier
-    if (importNode.type !== 'import_header')
-        return undefined;
-    const fullIdent = findChild(importNode, 'identifier');
-    if (!fullIdent)
-        return undefined;
-    const fullText = fullIdent.text;
-    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-    const importAlias = findChild(importNode, 'import_alias');
-    if (importAlias) {
-        // Aliased: import com.example.User as U
-        const aliasIdent = findChild(importAlias, 'simple_identifier');
-        if (!aliasIdent)
-            return undefined;
-        return [{ local: aliasIdent.text, exported: exportedName }];
-    }
-    // Non-aliased: import com.example.User → local="User", exported="User"
-    // Also handles top-level function imports: import models.getUser → local="getUser"
-    // Skip wildcard imports (ending in *)
-    if (fullText.endsWith('.*') || fullText.endsWith('*'))
-        return undefined;
-    // Skip class-member imports (e.g., import util.OneArg.writeAudit) where the
-    // second-to-last segment is PascalCase (a class name). Multiple member imports
-    // with the same function name would collide in NamedImportMap, breaking
-    // arity-based disambiguation. Top-level function imports (import models.getUser)
-    // and class imports (import models.User) have package-only prefixes.
-    const segments = fullText.split('.');
-    if (segments.length >= 3) {
-        const parentSegment = segments[segments.length - 2];
-        if (parentSegment[0] && parentSegment[0] === parentSegment[0].toUpperCase())
-            return undefined;
-    }
-    return [{ local: exportedName, exported: exportedName }];
-}

package/dist/core/ingestion/named-bindings/php.d.ts

@@ -1,3 +0,0 @@
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractPhpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/php.js

@@ -1,61 +0,0 @@
-export function extractPhpNamedBindings(importNode) {
-    // namespace_use_declaration > namespace_use_clause* (flat)
-    // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
-    if (importNode.type !== 'namespace_use_declaration')
-        return undefined;
-    // Skip 'use function' and 'use const' declarations — these import callables/constants,
-    // not class types, and should not be added to namedImportMap as type bindings.
-    const useTypeNode = importNode.childForFieldName?.('type');
-    if (useTypeNode && (useTypeNode.text === 'function' || useTypeNode.text === 'const')) {
-        return undefined;
-    }
-    const bindings = [];
-    // Collect all clauses — from direct children AND from namespace_use_group
-    const clauses = [];
-    for (let i = 0; i < importNode.namedChildCount; i++) {
-        const child = importNode.namedChild(i);
-        if (child?.type === 'namespace_use_clause') {
-            clauses.push(child);
-        }
-        else if (child?.type === 'namespace_use_group') {
-            for (let j = 0; j < child.namedChildCount; j++) {
-                const groupChild = child.namedChild(j);
-                if (groupChild?.type === 'namespace_use_clause')
-                    clauses.push(groupChild);
-            }
-        }
-    }
-    for (const clause of clauses) {
-        // Flat imports: qualified_name + name (alias)
-        let qualifiedName = null;
-        const names = [];
-        for (let j = 0; j < clause.namedChildCount; j++) {
-            const child = clause.namedChild(j);
-            if (child?.type === 'qualified_name')
-                qualifiedName = child;
-            else if (child?.type === 'name')
-                names.push(child);
-        }
-        if (qualifiedName && names.length > 0) {
-            // Flat aliased import: use App\Models\Repo as R;
-            const fullText = qualifiedName.text;
-            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: names[0].text, exported: exportedName });
-        }
-        else if (qualifiedName && names.length === 0) {
-            // Flat non-aliased import: use App\Models\User;
-            const fullText = qualifiedName.text;
-            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
-            bindings.push({ local: lastSegment, exported: lastSegment });
-        }
-        else if (!qualifiedName && names.length >= 2) {
-            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
-            bindings.push({ local: names[1].text, exported: names[0].text });
-        }
-        else if (!qualifiedName && names.length === 1) {
-            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
-            bindings.push({ local: names[0].text, exported: names[0].text });
-        }
-    }
-    return bindings.length > 0 ? bindings : undefined;
-}

package/dist/core/ingestion/named-bindings/python.d.ts

@@ -1,3 +0,0 @@
-import { type SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractPythonNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/python.js

@@ -1,49 +0,0 @@
-import { findChild } from '../utils/ast-helpers.js';
-export function extractPythonNamedBindings(importNode) {
-    // Handle: from x import User, Repo as R
-    if (importNode.type === 'import_from_statement') {
-        const bindings = [];
-        for (let i = 0; i < importNode.namedChildCount; i++) {
-            const child = importNode.namedChild(i);
-            if (!child)
-                continue;
-            if (child.type === 'dotted_name') {
-                // Skip the module_name (first dotted_name is the source module)
-                const fieldName = importNode.childForFieldName?.('module_name');
-                if (fieldName && child.startIndex === fieldName.startIndex)
-                    continue;
-                // This is an imported name: from x import User
-                const name = child.text;
-                if (name)
-                    bindings.push({ local: name, exported: name });
-            }
-            if (child.type === 'aliased_import') {
-                // from x import Repo as R
-                const dottedName = findChild(child, 'dotted_name');
-                const aliasIdent = findChild(child, 'identifier');
-                if (dottedName && aliasIdent) {
-                    bindings.push({ local: aliasIdent.text, exported: dottedName.text });
-                }
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    // Handle: import numpy as np  (import_statement with aliased_import child)
-    // Tagged with isModuleAlias so applyImportResult routes these directly to
-    // moduleAliasMap (e.g. "np" → "numpy.py") instead of namedImportMap.
-    if (importNode.type === 'import_statement') {
-        const bindings = [];
-        for (let i = 0; i < importNode.namedChildCount; i++) {
-            const child = importNode.namedChild(i);
-            if (!child || child.type !== 'aliased_import')
-                continue;
-            const dottedName = findChild(child, 'dotted_name');
-            const aliasIdent = findChild(child, 'identifier');
-            if (dottedName && aliasIdent) {
-                bindings.push({ local: aliasIdent.text, exported: dottedName.text, isModuleAlias: true });
-            }
-        }
-        return bindings.length > 0 ? bindings : undefined;
-    }
-    return undefined;
-}

package/dist/core/ingestion/named-bindings/rust.d.ts

@@ -1,3 +0,0 @@
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-import type { NamedBinding } from './types.js';
-export declare function extractRustNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/rust.js

@@ -1,66 +0,0 @@
-export function extractRustNamedBindings(importNode) {
-    // use_declaration may contain use_as_clause at any depth
-    if (importNode.type !== 'use_declaration')
-        return undefined;
-    const bindings = [];
-    collectRustBindings(importNode, bindings);
-    return bindings.length > 0 ? bindings : undefined;
-}
-function collectRustBindings(node, bindings) {
-    if (node.type === 'use_as_clause') {
-        // First identifier = exported name, second identifier = local alias
-        const idents = [];
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'identifier')
-                idents.push(child.text);
-            // For scoped_identifier, extract the last segment
-            if (child?.type === 'scoped_identifier') {
-                const nameNode = child.childForFieldName?.('name');
-                if (nameNode)
-                    idents.push(nameNode.text);
-            }
-        }
-        if (idents.length === 2) {
-            bindings.push({ local: idents[1], exported: idents[0] });
-        }
-        return;
-    }
-    // Terminal identifier in a use_list: use crate::models::{User, Repo}
-    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
-        bindings.push({ local: node.text, exported: node.text });
-        return;
-    }
-    // Skip scoped_identifier that serves as path prefix in scoped_use_list
-    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
-    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
-        return; // path prefix — the use_list sibling handles the actual symbols
-    }
-    // Terminal scoped_identifier: use crate::models::User;
-    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
-    if (node.type === 'scoped_identifier') {
-        let hasDeeper = false;
-        for (let i = 0; i < node.namedChildCount; i++) {
-            const child = node.namedChild(i);
-            if (child?.type === 'use_list' ||
-                child?.type === 'use_as_clause' ||
-                child?.type === 'scoped_use_list') {
-                hasDeeper = true;
-                break;
-            }
-        }
-        if (!hasDeeper) {
-            const nameNode = node.childForFieldName?.('name');
-            if (nameNode) {
-                bindings.push({ local: nameNode.text, exported: nameNode.text });
-            }
-            return;
-        }
-    }
-    // Recurse into children
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child)
-            collectRustBindings(child, bindings);
-    }
-}

package/dist/core/ingestion/named-bindings/types.d.ts

@@ -1,16 +0,0 @@
-/**
- * Named binding types — shared across all per-language binding extractors.
- *
- * Extracted from import-resolution.ts to co-locate types with their consumers.
- */
-import type { SyntaxNode } from '../utils/ast-helpers.js';
-/** 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;
-}
-/** Per-language named binding extractor -- optional (returns undefined if language has no named imports). */
-export type NamedBindingExtractorFn = (importNode: SyntaxNode) => NamedBinding[] | undefined;