@colbymchenry/codegraph 0.9.7 → 0.9.8

package/dist/resolution/frameworks/drupal.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Drupal Framework Resolver
+ *
+ * Supports Drupal 8/9/10/11 (Composer-based projects). Drupal 7 is not supported.
+ *
+ * ## What this resolver does
+ *
+ * 1. **Detection** — reads composer.json and checks for any `drupal/*` dependency in
+ *    `require` or `require-dev`.
+ *
+ * 2. **Route extraction** — parses `*.routing.yml` files and emits `route` nodes for each
+ *    Drupal route, with `references` edges to the `_controller`, `_form`, or entity handler
+ *    class/method.
+ *
+ * 3. **Hook detection** — scans `.module`, `.install`, `.theme`, and `.inc` files for Drupal
+ *    hook implementations. Two strategies are used:
+ *      a. Docblock: `@Implements hook_X()` → precise, no false positives.
+ *      b. Name pattern: function `{moduleName}_{hookSuffix}()` → catches hooks without
+ *         docblocks but may produce false positives on helper functions.
+ *    Detected hooks emit an `UnresolvedRef` from the implementing function node to the
+ *    canonical `hook_X` name, linking implementations to the hook when `codegraph_callers`
+ *    is invoked.
+ *
+ * ## Design decisions (review in future iterations)
+ *
+ * - Hook graph resolution (v1): hook references are stored as UnresolvedRef pointing to the
+ *   canonical `hook_X` name. If Drupal core is indexed, these will resolve to core hook
+ *   definitions. Without core, they remain unresolved but are still searchable via
+ *   `codegraph_search("form_alter")`. Full hook-node creation (virtual nodes for every hook)
+ *   is deferred to a future iteration.
+ *
+ * - Services / plugins (out of scope for v1): `*.services.yml` service definitions and plugin
+ *   annotations (`@Block`, `@FormElement`, etc.) are not extracted. Add a TODO below when
+ *   ready to implement.
+ *
+ * - Twig templates (out of scope for v1): `.twig` files are tracked as file nodes but no
+ *   symbol extraction is performed (no tree-sitter Twig grammar). Implement when a Twig
+ *   grammar WASM is available.
+ *
+ * ## TODOs for future iterations
+ *
+ * - TODO: Extract service definitions from `*.services.yml` files (class → service-id edges).
+ * - TODO: Extract plugin annotations (`@Block`, `@FormElement`, `@Field`, etc.) from PHP
+ *   docblocks and emit plugin nodes with references to the annotated class.
+ * - TODO: Add Twig symbol extraction when a tree-sitter Twig grammar becomes available.
+ * - TODO: Improve hook resolution: create virtual `hook_*` nodes so `codegraph_callers`
+ *   returns all implementations even when Drupal core is not indexed.
+ */
+import { FrameworkResolver } from '../types';
+export declare const drupalResolver: FrameworkResolver;
+//# sourceMappingURL=drupal.d.ts.map

package/dist/resolution/frameworks/expo-modules.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const expoModulesResolver: FrameworkResolver;
+//# sourceMappingURL=expo-modules.d.ts.map

package/dist/resolution/frameworks/express.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Express/Node.js Framework Resolver
+ *
+ * Handles Express and general Node.js patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const expressResolver: FrameworkResolver;
+//# sourceMappingURL=express.d.ts.map

package/dist/resolution/frameworks/fabric.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const fabricViewResolver: FrameworkResolver;
+//# sourceMappingURL=fabric.d.ts.map

package/dist/resolution/frameworks/go.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Go Framework Resolver
+ *
+ * Handles Gin, Echo, Fiber, Chi, and standard library patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const goResolver: FrameworkResolver;
+//# sourceMappingURL=go.d.ts.map

package/dist/resolution/frameworks/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Framework Resolver Registry
+ *
+ * Manages framework-specific resolvers.
+ */
+import { FrameworkResolver, ResolutionContext } from '../types';
+import type { Language } from '../../types';
+/**
+ * Get all framework resolvers
+ */
+export declare function getAllFrameworkResolvers(): FrameworkResolver[];
+/**
+ * Get a resolver by name
+ */
+export declare function getFrameworkResolver(name: string): FrameworkResolver | undefined;
+/**
+ * Detect which frameworks are used in a project
+ */
+export declare function detectFrameworks(context: ResolutionContext): FrameworkResolver[];
+/**
+ * Filter a list of detected frameworks down to ones that apply to a given language.
+ * Frameworks without an explicit `languages` list are treated as universal.
+ */
+export declare function getApplicableFrameworks(detected: FrameworkResolver[], language: Language): FrameworkResolver[];
+/**
+ * Register a custom framework resolver
+ */
+export declare function registerFrameworkResolver(resolver: FrameworkResolver): void;
+export { drupalResolver } from './drupal';
+export { laravelResolver, FACADE_MAPPINGS } from './laravel';
+export { expressResolver } from './express';
+export { nestjsResolver } from './nestjs';
+export { reactResolver } from './react';
+export { svelteResolver } from './svelte';
+export { vueResolver } from './vue';
+export { djangoResolver, flaskResolver, fastapiResolver } from './python';
+export { railsResolver } from './ruby';
+export { springResolver } from './java';
+export { playResolver } from './play';
+export { goResolver } from './go';
+export { rustResolver } from './rust';
+export { aspnetResolver } from './csharp';
+export { swiftUIResolver, uikitResolver, vaporResolver } from './swift';
+export { swiftObjcBridgeResolver } from './swift-objc';
+export { reactNativeBridgeResolver } from './react-native';
+export { expoModulesResolver } from './expo-modules';
+export { fabricViewResolver } from './fabric';
+//# sourceMappingURL=index.d.ts.map

package/dist/resolution/frameworks/java.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Java Framework Resolver
+ *
+ * Handles Spring Boot and general Java patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const springResolver: FrameworkResolver;
+//# sourceMappingURL=java.d.ts.map

package/dist/resolution/frameworks/laravel.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Laravel Framework Resolver
+ *
+ * Handles Laravel-specific patterns for reference resolution.
+ */
+import { FrameworkResolver } from '../types';
+/**
+ * Laravel facade mappings to underlying classes
+ * Exported for potential use in facade resolution
+ */
+export declare const FACADE_MAPPINGS: Record<string, string>;
+export declare const laravelResolver: FrameworkResolver;
+//# sourceMappingURL=laravel.d.ts.map

package/dist/resolution/frameworks/nestjs.d.ts

@@ -0,0 +1,26 @@
+/**
+ * NestJS Framework Resolver
+ *
+ * Handles NestJS decorator-based routing across its transport layers:
+ *   - HTTP:          @Controller(prefix) + @Get/@Post/@Put/@Patch/@Delete/@Head/@Options/@All
+ *   - GraphQL:       @Resolver + @Query/@Mutation/@Subscription
+ *   - Microservices: @MessagePattern / @EventPattern
+ *   - WebSockets:    @WebSocketGateway(namespace) + @SubscribeMessage(event)
+ *
+ * Like the other framework extractors this is regex-over-source (comment-
+ * stripped), not AST traversal. NestJS differs from Spring/ASP.NET in two ways
+ * that this resolver has to account for:
+ *
+ *   1. An HTTP route's path is split across TWO decorators — the class-level
+ *      `@Controller` prefix and the method-level `@Get`/`@Post` path — and both
+ *      are frequently empty (`@Controller()`, `@Get()`). We pair each method
+ *      decorator with its enclosing class and join the two paths.
+ *
+ *   2. `@Query()` is overloaded: it's a GraphQL *method* decorator (from
+ *      `@nestjs/graphql`) AND a REST *parameter* decorator (from
+ *      `@nestjs/common`). We only treat it as GraphQL when it sits inside an
+ *      `@Resolver` class, which is what disambiguates the two.
+ */
+import { FrameworkResolver } from '../types';
+export declare const nestjsResolver: FrameworkResolver;
+//# sourceMappingURL=nestjs.d.ts.map

package/dist/resolution/frameworks/play.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Play Framework (Scala/Java) resolver.
+ *
+ * Play declares HTTP routes in a dedicated `conf/routes` file (and included
+ * `conf/*.routes`), Rails-style:
+ *
+ *   GET   /computers        controllers.Application.list(p: Int ?= 0)
+ *   POST  /computers        controllers.Application.save
+ *   GET   /assets/*file     controllers.Assets.versioned(path = "/public", file: Asset)
+ *
+ * The file is extensionless, so the file walk only indexes it because
+ * `isPlayRoutesFile` (grammars.ts) opts it in; it's processed through the
+ * no-grammar path and this resolver extracts the routes. Each route references
+ * its handler as `Controller.method` (the package prefix is dropped), resolved
+ * to the action method in the controller class.
+ */
+import { FrameworkResolver } from '../types';
+export declare const playResolver: FrameworkResolver;
+//# sourceMappingURL=play.d.ts.map

package/dist/resolution/frameworks/python.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Python Framework Resolver
+ *
+ * Handles Django, Flask, and FastAPI patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const djangoResolver: FrameworkResolver;
+export declare const flaskResolver: FrameworkResolver;
+export declare const fastapiResolver: FrameworkResolver;
+//# sourceMappingURL=python.d.ts.map

package/dist/resolution/frameworks/react-native.d.ts

@@ -0,0 +1,3 @@
+import { FrameworkResolver } from '../types';
+export declare const reactNativeBridgeResolver: FrameworkResolver;
+//# sourceMappingURL=react-native.d.ts.map

package/dist/resolution/frameworks/react.d.ts

@@ -0,0 +1,8 @@
+/**
+ * React Framework Resolver
+ *
+ * Handles React and Next.js patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const reactResolver: FrameworkResolver;
+//# sourceMappingURL=react.d.ts.map

package/dist/resolution/frameworks/ruby.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby Framework Resolver
+ *
+ * Handles Ruby on Rails patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const railsResolver: FrameworkResolver;
+//# sourceMappingURL=ruby.d.ts.map

package/dist/resolution/frameworks/rust.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust Framework Resolver
+ *
+ * Handles Actix-web, Rocket, Axum, and common Rust patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const rustResolver: FrameworkResolver;
+//# sourceMappingURL=rust.d.ts.map

package/dist/resolution/frameworks/svelte.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Svelte / SvelteKit Framework Resolver
+ *
+ * Handles Svelte component references, Svelte 5 runes,
+ * store auto-subscriptions, and SvelteKit route/module patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const svelteResolver: FrameworkResolver;
+//# sourceMappingURL=svelte.d.ts.map

package/dist/resolution/frameworks/swift-objc.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Swift ↔ Objective-C bridge resolver.
+ *
+ * Closes the cross-language flow gap in mixed iOS codebases. The pure
+ * bridging name math lives in `../swift-objc-bridge.ts`; this file wires
+ * it into the resolution pipeline.
+ *
+ * **Two directions to close:**
+ *
+ * 1. **Swift call → ObjC method** — A Swift caller writes
+ *    `imageDownloader.download(url:completion:)`. Tree-sitter-swift parses
+ *    this as a call_expression whose callee identifier is `download`
+ *    (parameter labels live in the argument list, not the callee). The
+ *    name-matcher tries to find any node named `download` and fails (no
+ *    Swift method by that name in this project; the ObjC implementation is
+ *    `-downloadURL:completion:`). We catch it here: from the bare Swift
+ *    name `download`, look up ObjC methods whose bridged Swift base name
+ *    would be `download` (using `swiftBaseNamesForObjcSelector`'s reverse
+ *    map, precomputed once per session).
+ *
+ * 2. **ObjC call → Swift method** — An ObjC caller writes
+ *    `[swiftThing fooWithBar:42]`. Tree-sitter-objc parses this as a
+ *    message_expression with selector `fooWithBar:` (after the multi-
+ *    keyword fix in this branch). The name-matcher tries to find a node
+ *    named `fooWithBar:` — no Swift node has colons in its name, so it
+ *    fails. We catch it: from the ObjC selector, derive candidate Swift
+ *    base names (`['fooWithBar', 'foo']`), and look up Swift methods
+ *    named those.
+ *
+ * **Provenance:** every edge produced here is recorded as a framework-
+ * resolved reference (`resolvedBy: 'framework'`) with `confidence: 0.7`
+ * (matches the django ORM dynamic-dispatch precedent — not exact, but
+ * deterministic from the bridging rule).
+ */
+import { FrameworkResolver } from '../types';
+export declare const swiftObjcBridgeResolver: FrameworkResolver;
+//# sourceMappingURL=swift-objc.d.ts.map

package/dist/resolution/frameworks/swift.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Swift Framework Resolver
+ *
+ * Handles SwiftUI, UIKit, and Vapor (server-side Swift) patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const swiftUIResolver: FrameworkResolver;
+export declare const uikitResolver: FrameworkResolver;
+export declare const vaporResolver: FrameworkResolver;
+//# sourceMappingURL=swift.d.ts.map

package/dist/resolution/frameworks/vue.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Vue / Nuxt Framework Resolver
+ *
+ * Handles Vue component references, compiler macros (defineProps, etc.),
+ * Nuxt auto-imports, and Nuxt file-based routing patterns.
+ */
+import { FrameworkResolver } from '../types';
+export declare const vueResolver: FrameworkResolver;
+//# sourceMappingURL=vue.d.ts.map

package/dist/resolution/go-module.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Go module path detection.
+ *
+ * A Go monorepo's cross-package calls (`pkga.FuncX(...)`) only resolve when
+ * the resolver knows the project's module path (the `module ...` directive
+ * in `go.mod`). Without it, `isExternalImport` treats every in-module import
+ * — `github.com/example/myproject/pkga` — as a third-party package, so
+ * resolution falls through to name-matching with path proximity and returns
+ * a tiny fraction of the real call sites. See issue #388.
+ */
+export interface GoModule {
+    /** The module path declared in `go.mod`, e.g. `github.com/example/myproject` */
+    modulePath: string;
+    /** Absolute path to the directory containing the `go.mod` file. */
+    rootDir: string;
+}
+/**
+ * Read the `go.mod` file at the project root and extract the module path.
+ * Returns `null` if no `go.mod` exists or it has no `module` directive.
+ *
+ * Limitation: only the project-root `go.mod` is read. Nested `go.mod` files
+ * (Go workspaces, monorepos with multiple modules) are not yet resolved —
+ * a follow-up if a real repro shows up.
+ */
+export declare function loadGoModule(projectRoot: string): GoModule | null;
+//# sourceMappingURL=go-module.d.ts.map

package/dist/resolution/import-resolver.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Import Resolver
+ *
+ * Resolves import paths to actual files and symbols.
+ */
+import { Language } from '../types';
+import { UnresolvedRef, ResolvedRef, ResolutionContext, ImportMapping, ReExport } from './types';
+/**
+ * Resolve an import path to an actual file
+ */
+export declare function resolveImportPath(importPath: string, fromFile: string, language: Language, context: ResolutionContext): string | null;
+/**
+ * Clear the C/C++ include directory cache (call between indexing runs)
+ */
+export declare function clearCppIncludeDirCache(): void;
+/**
+ * Discover C/C++ include search directories for a project.
+ *
+ * Strategy:
+ * 1. Look for compile_commands.json (Clang compilation database) in the
+ *    project root and common build subdirectories. Parse -I and -isystem
+ *    flags from compiler commands.
+ * 2. If no compilation database is found, probe for common convention
+ *    directories (include/, src/, lib/, api/) and top-level directories
+ *    containing .h/.hpp files.
+ *
+ * Returns paths relative to projectRoot.
+ */
+export declare function loadCppIncludeDirs(projectRoot: string): string[];
+/**
+ * Extract import mappings from a file
+ */
+export declare function extractImportMappings(_filePath: string, content: string, language: Language): ImportMapping[];
+/**
+ * Clear the import mapping cache (call between indexing runs)
+ */
+export declare function clearImportMappingCache(): void;
+/**
+ * Extract JS/TS re-export declarations from `content`.
+ *
+ * Recognised forms:
+ *   export { foo } from './a';
+ *   export { foo as bar } from './a';
+ *   export * from './a';
+ *   export * as ns from './a';   (treated as wildcard for chasing)
+ *   export { default as Foo } from './a';
+ *
+ * The walker intentionally stays regex-based — the import-resolver
+ * elsewhere in this file already chooses regex over a fresh
+ * tree-sitter pass, and this function shares that trade-off. Errors
+ * fall through silently; resolution simply skips the broken file.
+ */
+export declare function extractReExports(content: string, language: Language): ReExport[];
+/**
+ * Resolve a reference using import mappings
+ */
+/**
+ * JVM (Java / Kotlin) imports use fully-qualified names (`import
+ * com.example.foo.Bar`) decoupled from filenames, so the JS/Python
+ * style filesystem path lookup misses them whenever the file isn't
+ * named after its primary symbol (Kotlin `Utils.kt` exporting `Bar`,
+ * top-level fns, extension fns). Resolve them through the
+ * `qualifiedName` index instead — populated by the package_header /
+ * package_declaration namespace wrappers in the extractor.
+ */
+export declare function resolveJvmImport(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+export declare function resolveViaImport(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+//# sourceMappingURL=import-resolver.d.ts.map

package/dist/resolution/index.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Reference Resolution Orchestrator
+ *
+ * Coordinates all reference resolution strategies.
+ */
+import { UnresolvedReference, Edge } from '../types';
+import { QueryBuilder } from '../db/queries';
+import { UnresolvedRef, ResolvedRef, ResolutionResult } from './types';
+export * from './types';
+/**
+ * Reference Resolver
+ *
+ * Orchestrates reference resolution using multiple strategies.
+ */
+export declare class ReferenceResolver {
+    private projectRoot;
+    private queries;
+    private context;
+    private frameworks;
+    private nodeCache;
+    private fileCache;
+    private importMappingCache;
+    private reExportCache;
+    private nameCache;
+    private lowerNameCache;
+    private qualifiedNameCache;
+    private knownNames;
+    private knownFiles;
+    private cachesWarmed;
+    private projectAliases;
+    private goModule;
+    constructor(projectRoot: string, queries: QueryBuilder);
+    /**
+     * Initialize the resolver (detect frameworks, etc.)
+     */
+    initialize(): void;
+    /**
+     * Run each framework resolver's cross-file finalization pass and persist
+     * the returned node updates. Idempotent — safe to call after every indexAll
+     * and every incremental sync. Returns the number of nodes updated.
+     *
+     * Caches are cleared before/after so the post-extract pass sees fresh DB
+     * state and downstream queries see the updated names.
+     */
+    runPostExtract(): number;
+    /**
+     * Pre-build lightweight caches for resolution.
+     * Node lookups are now handled by indexed SQLite queries instead of
+     * loading all nodes into memory (which caused OOM on large codebases).
+     * We cache the set of known symbol names for fast pre-filtering.
+     */
+    warmCaches(): void;
+    /**
+     * Clear internal caches
+     */
+    clearCaches(): void;
+    /**
+     * Create the resolution context
+     */
+    private createContext;
+    /**
+     * Resolve all unresolved references
+     */
+    resolveAll(unresolvedRefs: UnresolvedReference[], onProgress?: (current: number, total: number) => void): ResolutionResult;
+    /**
+     * Check if a reference name has any possible match in the codebase.
+     * Uses the pre-built knownNames set to skip expensive resolution
+     * for names that definitely don't exist as symbols.
+     */
+    private hasAnyPossibleMatch;
+    /**
+     * Does `ref.referenceName` match an import declared in its containing
+     * file? Used as a pre-filter escape so re-export chain resolution
+     * still gets a chance when the name has no project-wide declaration.
+     */
+    private matchesAnyImport;
+    /**
+     * Resolve a single reference
+     */
+    resolveOne(ref: UnresolvedRef): ResolvedRef | null;
+    /**
+     * Create edges from resolved references
+     */
+    createEdges(resolved: ResolvedRef[]): Edge[];
+    /**
+     * Resolve and persist edges to database
+     */
+    resolveAndPersist(unresolvedRefs: UnresolvedReference[], onProgress?: (current: number, total: number) => void): ResolutionResult;
+    /**
+     * Resolve and persist in batches to keep memory bounded.
+     * Processes unresolved references in chunks, persisting edges and cleaning
+     * up resolved refs after each batch to avoid accumulating large arrays.
+     */
+    resolveAndPersistBatched(onProgress?: (current: number, total: number) => void, batchSize?: number): Promise<ResolutionResult>;
+    /**
+     * Get detected frameworks
+     */
+    getDetectedFrameworks(): string[];
+    /**
+     * Check if reference is to a built-in or external symbol
+     */
+    private isBuiltInOrExternal;
+    /**
+     * Get file path from node ID
+     */
+    private getFilePathFromNodeId;
+    /**
+     * Get language from node ID
+     */
+    private getLanguageFromNodeId;
+}
+/**
+ * Create a reference resolver instance
+ */
+export declare function createResolver(projectRoot: string, queries: QueryBuilder): ReferenceResolver;
+//# sourceMappingURL=index.d.ts.map

package/dist/resolution/lru-cache.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Simple LRU cache backed by JavaScript's insertion-ordered Map.
+ *
+ * Used by ReferenceResolver to bound the per-resolver caches that
+ * previously grew without limit and OOM'd on large codebases (20k+
+ * files). Each cache is sized independently — see `index.ts` for
+ * the chosen limits per cache type.
+ *
+ * Eviction is plain LRU: on `set`, if the cache is full, the
+ * least-recently-used entry (the first one in iteration order) is
+ * evicted. Touching via `get` moves the entry to the most-recently-used
+ * position so hot keys survive eviction passes.
+ */
+export declare class LRUCache<K, V> {
+    private readonly max;
+    private readonly store;
+    constructor(max: number);
+    get size(): number;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    set(key: K, value: V): void;
+    clear(): void;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/dist/resolution/name-matcher.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Name Matcher
+ *
+ * Handles symbol name matching for reference resolution.
+ */
+import { UnresolvedRef, ResolvedRef, ResolutionContext } from './types';
+/**
+ * Try to resolve a path-like reference (e.g., "snippets/drawer-menu.liquid")
+ * by matching the filename against file nodes.
+ */
+export declare function matchByFilePath(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve a reference by exact name match
+ */
+export declare function matchByExactName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve by qualified name
+ */
+export declare function matchByQualifiedName(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Try to resolve by method name on a class/object
+ */
+export declare function matchMethodCall(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Fuzzy match - last resort with lower confidence
+ */
+export declare function matchFuzzy(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+/**
+ * Match all strategies in order of confidence
+ */
+export declare function matchReference(ref: UnresolvedRef, context: ResolutionContext): ResolvedRef | null;
+//# sourceMappingURL=name-matcher.d.ts.map

package/dist/resolution/path-aliases.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Project-level import-path alias loading.
+ *
+ * Reads `compilerOptions.paths` from `tsconfig.json` / `jsconfig.json`
+ * at the project root and converts the patterns into a form the
+ * import-resolver can consult.
+ *
+ * This is the single biggest blocker to accurate resolution on modern
+ * JS/TS codebases: aliases like `@/components/Foo` (Next, Nuxt, Nest,
+ * Vite scaffolds) point into a `paths` map the resolver previously
+ * ignored — every import through an alias was treated as unresolvable
+ * unless it happened to match the small hard-coded fallback list.
+ *
+ * Scope deliberately small for v1:
+ *   - reads tsconfig.json, then jsconfig.json
+ *   - honours top-level `compilerOptions.baseUrl` and `compilerOptions.paths`
+ *   - supports `*` wildcard (the only TS-supported wildcard)
+ *   - does NOT follow `extends` chains yet (most projects don't need it)
+ *   - does NOT read Vite/webpack/Rollup configs (separate follow-up)
+ *
+ * The file is parsed as JSON-with-comments-tolerant — tsconfigs in the
+ * wild routinely contain `//` and `/* *\/` comments and trailing
+ * commas, which JSON.parse rejects. We strip those before parsing.
+ */
+/** A single alias pattern from `compilerOptions.paths`. */
+export interface AliasPattern {
+    /** The literal prefix before `*` (or the whole pattern if no `*`). */
+    prefix: string;
+    /** The literal suffix after `*` (almost always empty). */
+    suffix: string;
+    /** Whether the pattern contains a `*` wildcard. */
+    hasWildcard: boolean;
+    /**
+     * Replacement templates. When `hasWildcard` is true, `*` in the
+     * replacement is filled with the captured wildcard portion of the
+     * import path. Stored relative to {@link AliasMap.baseUrl}.
+     * tsconfig allows multiple targets per alias (priority order).
+     */
+    replacements: string[];
+}
+export interface AliasMap {
+    /** Absolute path. The directory `compilerOptions.paths` is rooted at. */
+    baseUrl: string;
+    /**
+     * Patterns ordered by specificity: longer prefix first, then literal-
+     * before-wildcard, so the resolver tries the most-specific match.
+     */
+    patterns: AliasPattern[];
+}
+/**
+ * Load aliases for `projectRoot`. Returns `null` when no tsconfig /
+ * jsconfig is present or when the file has no usable `paths`.
+ *
+ * Cheap to call repeatedly — caching is the caller's job (the
+ * resolver does it via {@link aliasCache}).
+ */
+export declare function loadProjectAliases(projectRoot: string): AliasMap | null;
+/**
+ * Resolve an import path through an {@link AliasMap}. Returns the list
+ * of candidate filesystem paths (relative to `projectRoot`), in the
+ * priority order defined by tsconfig (multiple replacements per alias
+ * are tried in order). Returns `[]` when no alias matches.
+ *
+ * Callers still need to try each candidate with the language's
+ * extension list — this function only does the alias rewrite.
+ */
+export declare function applyAliases(importPath: string, aliases: AliasMap, projectRoot: string): string[];
+//# sourceMappingURL=path-aliases.d.ts.map