Merge origin/main into delphi-support

Integrate main branch changes (WASM grammar architecture, centralized
resolution caches, SQLite adapter) with delphi-support branch. Pascal
grammar is now built as WASM and shipped in src/extraction/wasm/ for
consistency with the WASM-based grammar loading approach.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/resolution/index.ts

@@ -15,9 +15,10 @@ import {
   ResolutionResult,
   ResolutionContext,
   FrameworkResolver,
+  ImportMapping,
 } from './types';
-import { matchReference, clearFuzzyIndex } from './name-matcher';
-import { resolveViaImport, clearImportMappingCache } from './import-resolver';
+import { matchReference } from './name-matcher';
+import { resolveViaImport, extractImportMappings } from './import-resolver';
 import { detectFrameworks } from './frameworks';
 import { logDebug } from '../errors';
 
@@ -40,6 +41,9 @@ export class ReferenceResolver {
   private qualifiedNameCache: Map<string, Node[]> = new Map();
   private kindCache: Map<string, Node[]> = new Map();
   private nodeByIdCache: Map<string, Node> = new Map();
+  private lowerNameCache: Map<string, Node[]> = new Map();
+  private importMappingCache: Map<string, ImportMapping[]> = new Map();
+  private knownFiles: Set<string> | null = null;
   private cachesWarmed = false;
 
   constructor(projectRoot: string, queries: QueryBuilder) {
@@ -91,8 +95,20 @@ export class ReferenceResolver {
 
       // Index by ID
       this.nodeByIdCache.set(node.id, node);
+
+      // Index by lowercase name (for fuzzy matching)
+      const lowerName = node.name.toLowerCase();
+      const byLower = this.lowerNameCache.get(lowerName);
+      if (byLower) {
+        byLower.push(node);
+      } else {
+        this.lowerNameCache.set(lowerName, [node]);
+      }
     }
 
+    // Pre-build known files set from index
+    this.knownFiles = new Set(this.queries.getAllFiles().map((f) => f.path));
+
     this.cachesWarmed = true;
   }
 
@@ -106,8 +122,9 @@ export class ReferenceResolver {
     this.qualifiedNameCache.clear();
     this.kindCache.clear();
     this.nodeByIdCache.clear();
-    clearImportMappingCache();
-    clearFuzzyIndex();
+    this.lowerNameCache.clear();
+    this.importMappingCache.clear();
+    this.knownFiles = null;
     this.cachesWarmed = false;
   }
 
@@ -150,6 +167,14 @@ export class ReferenceResolver {
       },
 
       fileExists: (filePath: string) => {
+        // Check pre-built known files set first (O(1))
+        if (this.knownFiles) {
+          const normalized = filePath.replace(/\\/g, '/');
+          if (this.knownFiles.has(filePath) || this.knownFiles.has(normalized)) {
+            return true;
+          }
+        }
+        // Fall back to filesystem for files not yet indexed
         const fullPath = path.join(this.projectRoot, filePath);
         try {
           return fs.existsSync(fullPath);
@@ -183,6 +208,32 @@ export class ReferenceResolver {
       getAllFiles: () => {
         return this.queries.getAllFiles().map((f) => f.path);
       },
+
+      getNodesByLowerName: (lowerName: string) => {
+        if (this.cachesWarmed) {
+          return this.lowerNameCache.get(lowerName) ?? [];
+        }
+        // Fallback: scan all nodes (expensive, but only used if cache not warm)
+        return this.queries.getAllNodes().filter(
+          (n) => n.name.toLowerCase() === lowerName
+        );
+      },
+
+      getImportMappings: (filePath: string, language) => {
+        const cacheKey = filePath;
+        const cached = this.importMappingCache.get(cacheKey);
+        if (cached) return cached;
+
+        const content = this.context.readFile(filePath);
+        if (!content) {
+          this.importMappingCache.set(cacheKey, []);
+          return [];
+        }
+
+        const mappings = extractImportMappings(filePath, content, language);
+        this.importMappingCache.set(cacheKey, mappings);
+        return mappings;
+      },
     };
   }