cotx-engine 0.1.0

package/dist/core/parser/pipeline.js

@@ -0,0 +1,1405 @@
+import { createKnowledgeGraph } from '../graph/graph.js';
+import { processStructure } from './structure-processor.js';
+import { processMarkdown } from './markdown-processor.js';
+import { processParsing } from './parsing-processor.js';
+import { processImports, processImportsFromExtracted, buildImportResolutionContext, } from './import-processor.js';
+import { EMPTY_INDEX } from './import-resolvers/utils.js';
+import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted, processNextjsFetchRoutes, extractFetchCallsFromFiles, seedCrossFileReceiverTypes, buildImportedReturnTypes, buildImportedRawReturnTypes, buildExportedTypeMapFromGraph, buildImplementorMap, mergeImplementorMaps, } from './call-processor.js';
+import { nextjsFileToRouteURL, normalizeFetchURL } from './route-extractors/nextjs.js';
+import { expoFileToRouteURL } from './route-extractors/expo.js';
+import { phpFileToRouteURL } from './route-extractors/php.js';
+import { extractResponseShapes, extractPHPResponseShapes, } from './route-extractors/response-shapes.js';
+import { extractMiddlewareChain, extractNextjsMiddlewareConfig, compileMatcher, compiledMatcherMatchesRoute, } from './route-extractors/middleware.js';
+import { generateId } from '../../lib/utils.js';
+import { processHeritage, processHeritageFromExtracted, extractExtractedHeritageFromFiles, } from './heritage-processor.js';
+import { computeMRO } from './mro-processor.js';
+import { processCommunities } from './community-processor.js';
+import { processProcesses } from './process-processor.js';
+import { createResolutionContext } from './resolution-context.js';
+import { createASTCache } from './ast-cache.js';
+import { getLanguageFromFilename } from '../shared/index.js';
+import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
+import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { providers, getProviderForFile } from './languages/index.js';
+import { createWorkerPool } from './workers/worker-pool.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+const isDev = process.env.NODE_ENV === 'development';
+const EXPO_NAV_PATTERNS = [
+    /router\.(push|replace|navigate)\(\s*['"`]([^'"`]+)['"`]/g,
+    /<Link\s+[^>]*href=\s*['"`]([^'"`]+)['"`]/g,
+];
+/** Kahn's algorithm: returns files grouped by topological level.
+ *  Files in the same level have no mutual dependencies — safe to process in parallel.
+ *  Files in cycles are returned as a final group (no cross-cycle propagation). */
+export function topologicalLevelSort(importMap) {
+    // Build in-degree map and reverse dependency map
+    const inDegree = new Map();
+    const reverseDeps = new Map();
+    for (const [file, deps] of importMap) {
+        if (!inDegree.has(file))
+            inDegree.set(file, 0);
+        for (const dep of deps) {
+            if (!inDegree.has(dep))
+                inDegree.set(dep, 0);
+            // file imports dep, so dep must be processed before file
+            // In Kahn's terms: dep → file (dep is a prerequisite of file)
+            inDegree.set(file, (inDegree.get(file) ?? 0) + 1);
+            let rev = reverseDeps.get(dep);
+            if (!rev) {
+                rev = [];
+                reverseDeps.set(dep, rev);
+            }
+            rev.push(file);
+        }
+    }
+    // BFS from zero-in-degree nodes, grouping by level
+    const levels = [];
+    let currentLevel = [...inDegree.entries()].filter(([, d]) => d === 0).map(([f]) => f);
+    while (currentLevel.length > 0) {
+        levels.push(currentLevel);
+        const nextLevel = [];
+        for (const file of currentLevel) {
+            for (const dependent of reverseDeps.get(file) ?? []) {
+                const newDeg = (inDegree.get(dependent) ?? 1) - 1;
+                inDegree.set(dependent, newDeg);
+                if (newDeg === 0)
+                    nextLevel.push(dependent);
+            }
+        }
+        currentLevel = nextLevel;
+    }
+    // Files still with positive in-degree are in cycles — add as final group
+    const cycleFiles = [...inDegree.entries()].filter(([, d]) => d > 0).map(([f]) => f);
+    if (cycleFiles.length > 0) {
+        levels.push(cycleFiles);
+    }
+    return { levels, cycleCount: cycleFiles.length };
+}
+/** Max bytes of source content to load per parse chunk. Each chunk's source +
+ *  parsed ASTs + extracted records + worker serialization overhead all live in
+ *  memory simultaneously, so this must be conservative. 20MB source ≈ 200-400MB
+ *  peak working memory per chunk after parse expansion. */
+const CHUNK_BYTE_BUDGET = 20 * 1024 * 1024; // 20MB
+/** Max AST trees to keep in LRU cache */
+const AST_CACHE_CAP = 50;
+/** Minimum percentage of files that must benefit from cross-file seeding to justify the re-resolution pass. */
+const CROSS_FILE_SKIP_THRESHOLD = 0.03;
+/** Hard cap on files re-processed during cross-file propagation. */
+const MAX_CROSS_FILE_REPROCESS = 2000;
+/** Node labels that represent top-level importable symbols.
+ *  Excludes Method, Property, Constructor (accessed via receiver, not directly imported),
+ *  and structural labels (File, Folder, Package, Module, Project, etc.). */
+const IMPORTABLE_SYMBOL_LABELS = new Set([
+    'Function',
+    'Class',
+    'Interface',
+    'Struct',
+    'Enum',
+    'Trait',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Record',
+    'Union',
+    'Typedef',
+    'Macro',
+]);
+/** Max synthetic bindings per importing file — prevents memory bloat for
+ *  C/C++ files that include many large headers. */
+const MAX_SYNTHETIC_BINDINGS_PER_FILE = 1000;
+/** Pre-computed language sets derived from providers at module load. */
+const WILDCARD_LANGUAGES = new Set(Object.values(providers)
+    .filter((p) => p.importSemantics === 'wildcard')
+    .map((p) => p.id));
+const SYNTHESIS_LANGUAGES = new Set(Object.values(providers)
+    .filter((p) => p.importSemantics !== 'named')
+    .map((p) => p.id));
+/** Check if a language uses wildcard (whole-module) import semantics.
+ *  Derived from LanguageProvider.importSemantics — no hardcoded set needed. */
+function isWildcardImportLanguage(lang) {
+    return WILDCARD_LANGUAGES.has(lang);
+}
+/** Check if a language needs synthesis before call resolution.
+ *  True for wildcard-import languages AND namespace-import languages (Python). */
+function needsSynthesis(lang) {
+    return SYNTHESIS_LANGUAGES.has(lang);
+}
+/** Synthesize namedImportMap entries for languages with whole-module imports.
+ *  These languages (Go, Ruby, C/C++, Swift, Python) import all exported symbols from a
+ *  file, not specific named symbols. After parsing, we know which symbols each file
+ *  exports (via graph isExported), so we can expand ImportMap edges into per-symbol
+ *  bindings that Phase 14 can use for cross-file type propagation. */
+function synthesizeWildcardImportBindings(graph, ctx) {
+    // Pre-compute exported symbols per file from graph (single pass)
+    const exportedSymbolsByFile = new Map();
+    graph.forEachNode((node) => {
+        if (!node.properties?.isExported)
+            return;
+        if (!IMPORTABLE_SYMBOL_LABELS.has(node.label))
+            return;
+        const fp = node.properties.filePath;
+        const name = node.properties.name;
+        if (!fp || !name)
+            return;
+        let symbols = exportedSymbolsByFile.get(fp);
+        if (!symbols) {
+            symbols = [];
+            exportedSymbolsByFile.set(fp, symbols);
+        }
+        symbols.push({ name, filePath: fp });
+    });
+    if (exportedSymbolsByFile.size === 0)
+        return 0;
+    // Build a merged import map: ctx.importMap has file-based imports (Ruby, C/C++),
+    // but Go/C# package imports use graph IMPORTS edges + PackageMap instead.
+    // Collect graph-level IMPORTS edges for wildcard languages missing from ctx.importMap.
+    const FILE_PREFIX = 'File:';
+    const graphImports = new Map();
+    graph.forEachRelationship((rel) => {
+        if (rel.type !== 'IMPORTS')
+            return;
+        if (!rel.sourceId.startsWith(FILE_PREFIX) || !rel.targetId.startsWith(FILE_PREFIX))
+            return;
+        const srcFile = rel.sourceId.slice(FILE_PREFIX.length);
+        const tgtFile = rel.targetId.slice(FILE_PREFIX.length);
+        const lang = getLanguageFromFilename(srcFile);
+        if (!lang || !isWildcardImportLanguage(lang))
+            return;
+        // Only add if not already in ctx.importMap (avoid duplicates)
+        if (ctx.importMap.get(srcFile)?.has(tgtFile))
+            return;
+        let set = graphImports.get(srcFile);
+        if (!set) {
+            set = new Set();
+            graphImports.set(srcFile, set);
+        }
+        set.add(tgtFile);
+    });
+    let totalSynthesized = 0;
+    // Helper: synthesize bindings for a file given its imported files
+    const synthesizeForFile = (filePath, importedFiles) => {
+        let fileBindings = ctx.namedImportMap.get(filePath);
+        let fileCount = fileBindings?.size ?? 0;
+        for (const importedFile of importedFiles) {
+            const exportedSymbols = exportedSymbolsByFile.get(importedFile);
+            if (!exportedSymbols)
+                continue;
+            for (const sym of exportedSymbols) {
+                if (fileCount >= MAX_SYNTHETIC_BINDINGS_PER_FILE)
+                    return;
+                if (fileBindings?.has(sym.name))
+                    continue;
+                if (!fileBindings) {
+                    fileBindings = new Map();
+                    ctx.namedImportMap.set(filePath, fileBindings);
+                }
+                fileBindings.set(sym.name, {
+                    sourcePath: importedFile,
+                    exportedName: sym.name,
+                });
+                fileCount++;
+                totalSynthesized++;
+            }
+        }
+    };
+    // Process files from ctx.importMap (Ruby, C/C++, Swift file-based imports)
+    for (const [filePath, importedFiles] of ctx.importMap) {
+        const lang = getLanguageFromFilename(filePath);
+        if (!lang || !isWildcardImportLanguage(lang))
+            continue;
+        synthesizeForFile(filePath, importedFiles);
+    }
+    // Process files from graph IMPORTS edges (Go and other wildcard-import languages)
+    for (const [filePath, importedFiles] of graphImports) {
+        synthesizeForFile(filePath, importedFiles);
+    }
+    // Build module alias map for Python namespace imports.
+    // `import models` in app.py → ctx.moduleAliasMap['app.py']['models'] = 'models.py'
+    // Enables `models.User()` to resolve to models.py:User without ambiguous symbol expansion.
+    const buildPythonModuleAliasForFile = (callerFile, importedFiles) => {
+        let aliasMap = ctx.moduleAliasMap.get(callerFile);
+        for (const importedFile of importedFiles) {
+            // Derive the module alias from the imported filename stem (e.g. "models.py" → "models")
+            const lastSlash = importedFile.lastIndexOf('/');
+            const base = lastSlash >= 0 ? importedFile.slice(lastSlash + 1) : importedFile;
+            const dot = base.lastIndexOf('.');
+            const stem = dot >= 0 ? base.slice(0, dot) : base;
+            if (!stem)
+                continue;
+            if (!aliasMap) {
+                aliasMap = new Map();
+                ctx.moduleAliasMap.set(callerFile, aliasMap);
+            }
+            aliasMap.set(stem, importedFile);
+        }
+    };
+    for (const [filePath, importedFiles] of ctx.importMap) {
+        const provider = getProviderForFile(filePath);
+        if (!provider || provider.importSemantics !== 'namespace')
+            continue;
+        buildPythonModuleAliasForFile(filePath, importedFiles);
+    }
+    return totalSynthesized;
+}
+/** Phase 14: Cross-file binding propagation.
+ *  Seeds downstream files with resolved type bindings from upstream exports.
+ *  Files are processed in topological import order so upstream bindings are
+ *  available when downstream files are re-resolved. */
+async function runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPaths, totalFiles, repoPath, pipelineStart, onProgress) {
+    // For the worker path, buildTypeEnv runs inside workers without SymbolTable,
+    // so exported bindings must be collected from graph + SymbolTable in main thread.
+    if (exportedTypeMap.size === 0 && graph.nodeCount > 0) {
+        const graphExports = buildExportedTypeMapFromGraph(graph, ctx.symbols);
+        for (const [fp, exports] of graphExports)
+            exportedTypeMap.set(fp, exports);
+    }
+    if (exportedTypeMap.size === 0 || ctx.namedImportMap.size === 0)
+        return;
+    const allPathSet = new Set(allPaths);
+    const { levels, cycleCount } = topologicalLevelSort(ctx.importMap);
+    // Cycle diagnostic: only log when actual cycles detected (cycleCount from Kahn's BFS)
+    if (isDev && cycleCount > 0) {
+        console.log(`🔄 ${cycleCount} files in import cycles (skipped for cross-file propagation)`);
+    }
+    // Quick count of files with cross-file binding gaps (early exit once threshold exceeded)
+    let filesWithGaps = 0;
+    const gapThreshold = Math.max(1, Math.ceil(totalFiles * CROSS_FILE_SKIP_THRESHOLD));
+    outer: for (const level of levels) {
+        for (const filePath of level) {
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            for (const [, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream?.has(binding.exportedName)) {
+                    filesWithGaps++;
+                    break;
+                }
+                const def = ctx.symbols.lookupExactFull(binding.sourcePath, binding.exportedName);
+                if (def?.returnType) {
+                    filesWithGaps++;
+                    break;
+                }
+            }
+            if (filesWithGaps >= gapThreshold)
+                break outer;
+        }
+    }
+    const gapRatio = totalFiles > 0 ? filesWithGaps / totalFiles : 0;
+    if (gapRatio < CROSS_FILE_SKIP_THRESHOLD && filesWithGaps < gapThreshold) {
+        if (isDev) {
+            console.log(`⏭️ Cross-file re-resolution skipped (${filesWithGaps}/${totalFiles} files, ${(gapRatio * 100).toFixed(1)}% < ${CROSS_FILE_SKIP_THRESHOLD * 100}% threshold)`);
+        }
+        return;
+    }
+    onProgress({
+        phase: 'parsing',
+        percent: 82,
+        message: `Cross-file type propagation (${filesWithGaps}+ files)...`,
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    let crossFileResolved = 0;
+    const crossFileStart = Date.now();
+    const astCache = createASTCache(AST_CACHE_CAP);
+    for (const level of levels) {
+        const levelCandidates = [];
+        for (const filePath of level) {
+            if (crossFileResolved + levelCandidates.length >= MAX_CROSS_FILE_REPROCESS)
+                break;
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            const seeded = new Map();
+            for (const [localName, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream) {
+                    const type = upstream.get(binding.exportedName);
+                    if (type)
+                        seeded.set(localName, type);
+                }
+            }
+            const importedReturns = buildImportedReturnTypes(filePath, ctx.namedImportMap, ctx.symbols);
+            const importedRawReturns = buildImportedRawReturnTypes(filePath, ctx.namedImportMap, ctx.symbols);
+            if (seeded.size === 0 && importedReturns.size === 0)
+                continue;
+            if (!allPathSet.has(filePath))
+                continue;
+            const lang = getLanguageFromFilename(filePath);
+            if (!lang || !isLanguageAvailable(lang))
+                continue;
+            levelCandidates.push({ filePath, seeded, importedReturns, importedRawReturns });
+        }
+        if (levelCandidates.length === 0)
+            continue;
+        const levelPaths = levelCandidates.map((c) => c.filePath);
+        const contentMap = await readFileContents(repoPath, levelPaths);
+        for (const { filePath, seeded, importedReturns, importedRawReturns } of levelCandidates) {
+            const content = contentMap.get(filePath);
+            if (!content)
+                continue;
+            const reFile = [{ path: filePath, content }];
+            const bindings = new Map();
+            if (seeded.size > 0)
+                bindings.set(filePath, seeded);
+            const importedReturnTypesMap = new Map();
+            if (importedReturns.size > 0) {
+                importedReturnTypesMap.set(filePath, importedReturns);
+            }
+            const importedRawReturnTypesMap = new Map();
+            if (importedRawReturns.size > 0) {
+                importedRawReturnTypesMap.set(filePath, importedRawReturns);
+            }
+            await processCalls(graph, reFile, astCache, ctx, undefined, exportedTypeMap, bindings.size > 0 ? bindings : undefined, importedReturnTypesMap.size > 0 ? importedReturnTypesMap : undefined, importedRawReturnTypesMap.size > 0 ? importedRawReturnTypesMap : undefined);
+            crossFileResolved++;
+        }
+        if (crossFileResolved >= MAX_CROSS_FILE_REPROCESS) {
+            if (isDev)
+                console.log(`⚠️ Cross-file re-resolution capped at ${MAX_CROSS_FILE_REPROCESS} files`);
+            break;
+        }
+    }
+    astCache.clear();
+    if (isDev) {
+        const elapsed = Date.now() - crossFileStart;
+        const totalElapsed = Date.now() - pipelineStart;
+        const reResolutionPct = totalElapsed > 0 ? ((elapsed / totalElapsed) * 100).toFixed(1) : '0';
+        console.log(`🔗 Cross-file re-resolution: ${crossFileResolved} candidates re-processed` +
+            ` in ${elapsed}ms (${reResolutionPct}% of total ingestion time so far)`);
+    }
+}
+/**
+ * Phase 1+2: Scan repository paths, build file/folder structure, process markdown.
+ *
+ * @reads  repoPath (filesystem)
+ * @writes graph (File, Folder nodes + CONTAINS edges; Markdown sections + cross-links)
+ */
+async function runScanAndStructure(repoPath, graph, onProgress) {
+    // ── Phase 1: Scan paths only (no content read) ─────────────────────
+    onProgress({
+        phase: 'extracting',
+        percent: 0,
+        message: 'Scanning repository...',
+    });
+    const scannedFiles = await walkRepositoryPaths(repoPath, (current, total, filePath) => {
+        const scanProgress = Math.round((current / total) * 15);
+        onProgress({
+            phase: 'extracting',
+            percent: scanProgress,
+            message: 'Scanning repository...',
+            detail: filePath,
+            stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount },
+        });
+    });
+    const totalFiles = scannedFiles.length;
+    onProgress({
+        phase: 'extracting',
+        percent: 15,
+        message: 'Repository scanned successfully',
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    // ── Phase 2: Structure (paths only — no content needed) ────────────
+    onProgress({
+        phase: 'structure',
+        percent: 15,
+        message: 'Analyzing project structure...',
+        stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    const allPaths = scannedFiles.map((f) => f.path);
+    processStructure(graph, allPaths);
+    onProgress({
+        phase: 'structure',
+        percent: 20,
+        message: 'Project structure analyzed',
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    // ── Custom (non-tree-sitter) processors ─────────────────────────────
+    // Each custom processor follows the pattern in markdown-processor.ts:
+    //   1. Export a process function: (graph, files, allPathSet) => result
+    //   2. Export a file detection function: (path) => boolean
+    //   3. Filter files by extension, write nodes/edges directly to graph
+    // To add a new language: create a new processor file, import it here,
+    // and add a filter-read-call-log block following the pattern below.
+    // ── Phase 2.5: Markdown processing (headings + cross-links) ────────
+    const mdScanned = scannedFiles.filter((f) => f.path.endsWith('.md') || f.path.endsWith('.mdx'));
+    if (mdScanned.length > 0) {
+        const mdContents = await readFileContents(repoPath, mdScanned.map((f) => f.path));
+        const mdFiles = mdScanned
+            .filter((f) => mdContents.has(f.path))
+            .map((f) => ({ path: f.path, content: mdContents.get(f.path) }));
+        const allPathSet = new Set(allPaths);
+        const mdResult = processMarkdown(graph, mdFiles, allPathSet);
+        if (isDev) {
+            console.log(`  Markdown: ${mdResult.sections} sections, ${mdResult.links} cross-links from ${mdFiles.length} files`);
+        }
+    }
+    // COBOL processing removed (not included in cotx-engine fork)
+    return { scannedFiles, allPaths, totalFiles };
+}
+/**
+ * Phase 3+4: Chunked parse + resolve loop.
+ *
+ * Reads source in byte-budget chunks (~20MB each). For each chunk:
+ * 1. Parse via worker pool (or sequential fallback)
+ * 2. Resolve imports from extracted data
+ * 3. Synthesize wildcard import bindings (Go/Ruby/C++/Swift/Python)
+ * 4. Resolve heritage + routes per chunk; defer worker CALLS until all chunks
+ *    have contributed heritage so interface-dispatch implementor map is complete
+ * 5. Collect TypeEnv bindings for cross-file propagation
+ *
+ * State accumulated across chunks: symbolTable, importMap, namedImportMap,
+ * moduleAliasMap (all via ResolutionContext), exportedTypeMap, workerTypeEnvBindings.
+ *
+ * @reads  graph (structure nodes from Phase 1+2)
+ * @reads  allPaths (from scan phase)
+ * @writes graph (Symbol nodes, IMPORTS/CALLS/EXTENDS/IMPLEMENTS/ACCESSES edges)
+ * @writes ctx.symbolTable, ctx.importMap, ctx.namedImportMap, ctx.moduleAliasMap
+ *
+ * Follow-up from PR review: MethodExtractor (FieldExtractor parity) and optional
+ * METHOD_IMPLEMENTS graph edges to make dispatch queryable without an in-memory map.
+ */
+async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress) {
+    const symbolTable = ctx.symbols;
+    const parseableScanned = scannedFiles.filter((f) => {
+        const lang = getLanguageFromFilename(f.path);
+        return lang && isLanguageAvailable(lang);
+    });
+    // Warn about files skipped due to unavailable parsers
+    const skippedByLang = new Map();
+    for (const f of scannedFiles) {
+        const lang = getLanguageFromFilename(f.path);
+        if (lang && !isLanguageAvailable(lang)) {
+            skippedByLang.set(lang, (skippedByLang.get(lang) || 0) + 1);
+        }
+    }
+    for (const [lang, count] of skippedByLang) {
+        console.warn(`Skipping ${count} ${lang} file(s) — ${lang} parser not available (native binding may not have built). Try: npm rebuild tree-sitter-${lang}`);
+    }
+    const totalParseable = parseableScanned.length;
+    if (totalParseable === 0) {
+        onProgress({
+            phase: 'parsing',
+            percent: 82,
+            message: 'No parseable files found — skipping parsing phase',
+            stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount },
+        });
+    }
+    // Build byte-budget chunks
+    const chunks = [];
+    let currentChunk = [];
+    let currentBytes = 0;
+    for (const file of parseableScanned) {
+        if (currentChunk.length > 0 && currentBytes + file.size > CHUNK_BYTE_BUDGET) {
+            chunks.push(currentChunk);
+            currentChunk = [];
+            currentBytes = 0;
+        }
+        currentChunk.push(file.path);
+        currentBytes += file.size;
+    }
+    if (currentChunk.length > 0)
+        chunks.push(currentChunk);
+    const numChunks = chunks.length;
+    if (isDev) {
+        const totalMB = parseableScanned.reduce((s, f) => s + f.size, 0) / (1024 * 1024);
+        console.log(`📂 Scan: ${totalFiles} paths, ${totalParseable} parseable (${totalMB.toFixed(0)}MB), ${numChunks} chunks @ ${CHUNK_BYTE_BUDGET / (1024 * 1024)}MB budget`);
+    }
+    onProgress({
+        phase: 'parsing',
+        percent: 20,
+        message: `Parsing ${totalParseable} files in ${numChunks} chunk${numChunks !== 1 ? 's' : ''}...`,
+        stats: { filesProcessed: 0, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+    });
+    // Don't spawn workers for tiny repos — overhead exceeds benefit
+    const MIN_FILES_FOR_WORKERS = 15;
+    const MIN_BYTES_FOR_WORKERS = 512 * 1024;
+    const totalBytes = parseableScanned.reduce((s, f) => s + f.size, 0);
+    // Create worker pool once, reuse across chunks
+    let workerPool;
+    if (totalParseable >= MIN_FILES_FOR_WORKERS || totalBytes >= MIN_BYTES_FOR_WORKERS) {
+        try {
+            let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
+            // When running under vitest, import.meta.url points to src/ where no .js exists.
+            // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
+            const thisDir = fileURLToPath(new URL('.', import.meta.url));
+            if (!fs.existsSync(fileURLToPath(workerUrl))) {
+                const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
+                if (fs.existsSync(distWorker)) {
+                    workerUrl = pathToFileURL(distWorker);
+                }
+            }
+            workerPool = createWorkerPool(workerUrl);
+        }
+        catch (err) {
+            if (isDev)
+                console.warn('Worker pool creation failed, using sequential fallback:', err.message);
+        }
+    }
+    let filesParsedSoFar = 0;
+    // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)
+    const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0);
+    let astCache = createASTCache(maxChunkFiles);
+    // Build import resolution context once — suffix index, file lists, resolve cache.
+    // Reused across all chunks to avoid rebuilding O(files × path_depth) structures.
+    const importCtx = buildImportResolutionContext(allPaths);
+    const allPathObjects = allPaths.map((p) => ({ path: p }));
+    // Worker path: parse + imports + heritage per chunk; buffer extracted calls and
+    // run processCallsFromExtracted once after all chunks so interface-dispatch uses a
+    // complete implementor map (heritage from every chunk). Costs peak RAM for buffered
+    // call rows vs streaming resolution per chunk.
+    const sequentialChunkPaths = [];
+    // Pre-compute which chunks need synthesis — O(1) lookup per chunk.
+    const chunkNeedsSynthesis = chunks.map((paths) => paths.some((p) => {
+        const lang = getLanguageFromFilename(p);
+        return lang != null && needsSynthesis(lang);
+    }));
+    // Phase 14: Collect exported type bindings for cross-file propagation
+    const exportedTypeMap = new Map();
+    // Accumulate file-scope TypeEnv bindings from workers (closes worker/sequential quality gap)
+    const workerTypeEnvBindings = [];
+    // Accumulate fetch() calls from workers for Next.js route matching
+    const allFetchCalls = [];
+    // Accumulate framework-extracted routes (Laravel, etc.) for Route node creation
+    const allExtractedRoutes = [];
+    // Accumulate decorator-based routes (@Get, @Post, @app.route, etc.)
+    const allDecoratorRoutes = [];
+    // Accumulate MCP/RPC tool definitions (@mcp.tool(), @app.tool(), etc.)
+    const allToolDefs = [];
+    const allORMQueries = [];
+    const deferredWorkerCalls = [];
+    const deferredWorkerHeritage = [];
+    const deferredConstructorBindings = [];
+    const deferredAssignments = [];
+    try {
+        for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+            const chunkPaths = chunks[chunkIdx];
+            // Read content for this chunk only
+            const chunkContents = await readFileContents(repoPath, chunkPaths);
+            const chunkFiles = chunkPaths
+                .filter((p) => chunkContents.has(p))
+                .map((p) => ({ path: p, content: chunkContents.get(p) }));
+            // Parse this chunk (workers or sequential fallback)
+            const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
+                const globalCurrent = filesParsedSoFar + current;
+                const parsingProgress = 20 + (globalCurrent / totalParseable) * 62;
+                onProgress({
+                    phase: 'parsing',
+                    percent: Math.round(parsingProgress),
+                    message: `Parsing chunk ${chunkIdx + 1}/${numChunks}...`,
+                    detail: filePath,
+                    stats: {
+                        filesProcessed: globalCurrent,
+                        totalFiles: totalParseable,
+                        nodesCreated: graph.nodeCount,
+                    },
+                });
+            }, workerPool);
+            const chunkBasePercent = 20 + (filesParsedSoFar / totalParseable) * 62;
+            if (chunkWorkerData) {
+                // Imports
+                await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {
+                    onProgress({
+                        phase: 'parsing',
+                        percent: Math.round(chunkBasePercent),
+                        message: `Resolving imports (chunk ${chunkIdx + 1}/${numChunks})...`,
+                        detail: `${current}/${total} files`,
+                        stats: {
+                            filesProcessed: filesParsedSoFar,
+                            totalFiles: totalParseable,
+                            nodesCreated: graph.nodeCount,
+                        },
+                    });
+                }, repoPath, importCtx);
+                // ── Wildcard-import synthesis (Ruby / C/C++ / Swift / Go) + Python module aliases ─
+                // Synthesize namedImportMap entries for wildcard-import languages and build
+                // moduleAliasMap for Python namespace imports. Must run after imports are resolved
+                // (importMap is populated) but BEFORE call resolution.
+                if (chunkNeedsSynthesis[chunkIdx])
+                    synthesizeWildcardImportBindings(graph, ctx);
+                // Phase 14 E1: Seed cross-file receiver types from ExportedTypeMap
+                // before call resolution — eliminates re-parse for single-hop imported receivers.
+                // NOTE: In the worker path, exportedTypeMap is empty during chunk processing
+                // (populated later in runCrossFileBindingPropagation). This block is latent —
+                // it activates only if incremental export collection is added per-chunk.
+                if (exportedTypeMap.size > 0 && ctx.namedImportMap.size > 0) {
+                    const { enrichedCount } = seedCrossFileReceiverTypes(chunkWorkerData.calls, ctx.namedImportMap, exportedTypeMap);
+                    if (isDev && enrichedCount > 0) {
+                        console.log(`🔗 E1: Seeded ${enrichedCount} cross-file receiver types (chunk ${chunkIdx + 1})`);
+                    }
+                }
+                deferredWorkerCalls.push(...chunkWorkerData.calls);
+                deferredWorkerHeritage.push(...chunkWorkerData.heritage);
+                deferredConstructorBindings.push(...chunkWorkerData.constructorBindings);
+                if (chunkWorkerData.assignments?.length) {
+                    deferredAssignments.push(...chunkWorkerData.assignments);
+                }
+                // Heritage + Routes — calls deferred until all chunks have contributed heritage
+                // (complete implementor map for interface dispatch).
+                await Promise.all([
+                    processHeritageFromExtracted(graph, chunkWorkerData.heritage, ctx, (current, total) => {
+                        onProgress({
+                            phase: 'parsing',
+                            percent: Math.round(chunkBasePercent),
+                            message: `Resolving heritage (chunk ${chunkIdx + 1}/${numChunks})...`,
+                            detail: `${current}/${total} records`,
+                            stats: {
+                                filesProcessed: filesParsedSoFar,
+                                totalFiles: totalParseable,
+                                nodesCreated: graph.nodeCount,
+                            },
+                        });
+                    }),
+                    processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], ctx, (current, total) => {
+                        onProgress({
+                            phase: 'parsing',
+                            percent: Math.round(chunkBasePercent),
+                            message: `Resolving routes (chunk ${chunkIdx + 1}/${numChunks})...`,
+                            detail: `${current}/${total} routes`,
+                            stats: {
+                                filesProcessed: filesParsedSoFar,
+                                totalFiles: totalParseable,
+                                nodesCreated: graph.nodeCount,
+                            },
+                        });
+                    }),
+                ]);
+                // Collect TypeEnv file-scope bindings for exported type enrichment
+                if (chunkWorkerData.typeEnvBindings?.length) {
+                    workerTypeEnvBindings.push(...chunkWorkerData.typeEnvBindings);
+                }
+                // Collect fetch() calls for Next.js route matching
+                if (chunkWorkerData.fetchCalls?.length) {
+                    allFetchCalls.push(...chunkWorkerData.fetchCalls);
+                }
+                if (chunkWorkerData.routes?.length) {
+                    allExtractedRoutes.push(...chunkWorkerData.routes);
+                }
+                if (chunkWorkerData.decoratorRoutes?.length) {
+                    allDecoratorRoutes.push(...chunkWorkerData.decoratorRoutes);
+                }
+                if (chunkWorkerData.toolDefs?.length) {
+                    allToolDefs.push(...chunkWorkerData.toolDefs);
+                }
+                if (chunkWorkerData.ormQueries?.length) {
+                    allORMQueries.push(...chunkWorkerData.ormQueries);
+                }
+            }
+            else {
+                await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
+                sequentialChunkPaths.push(chunkPaths);
+            }
+            filesParsedSoFar += chunkFiles.length;
+            // Clear AST cache between chunks to free memory
+            astCache.clear();
+            // chunkContents + chunkFiles + chunkWorkerData go out of scope → GC reclaims
+        }
+        // Complete implementor map from all worker heritage, then resolve CALLS once (interface dispatch).
+        const fullWorkerImplementorMap = deferredWorkerHeritage.length > 0
+            ? buildImplementorMap(deferredWorkerHeritage, ctx)
+            : new Map();
+        if (deferredWorkerCalls.length > 0) {
+            await processCallsFromExtracted(graph, deferredWorkerCalls, ctx, (current, total) => {
+                onProgress({
+                    phase: 'parsing',
+                    percent: 82,
+                    message: 'Resolving calls (all chunks)...',
+                    detail: `${current}/${total} files`,
+                    stats: {
+                        filesProcessed: filesParsedSoFar,
+                        totalFiles: totalParseable,
+                        nodesCreated: graph.nodeCount,
+                    },
+                });
+            }, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, fullWorkerImplementorMap);
+        }
+        if (deferredAssignments.length > 0) {
+            processAssignmentsFromExtracted(graph, deferredAssignments, ctx, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined);
+        }
+    }
+    finally {
+        await workerPool?.terminate();
+    }
+    // Sequential fallback chunks: re-read source for call/heritage resolution
+    // Synthesize wildcard import bindings once after ALL imports are processed,
+    // before any call resolution — same rationale as the worker-path inline synthesis.
+    if (sequentialChunkPaths.length > 0)
+        synthesizeWildcardImportBindings(graph, ctx);
+    // Merge implementor-map deltas per chunk (O(heritage per chunk)), not O(|edges|) graph scans
+    // per chunk — mirrors worker-path deferred heritage without re-iterating all relationships.
+    const sequentialImplementorMap = new Map();
+    for (const chunkPaths of sequentialChunkPaths) {
+        const chunkContents = await readFileContents(repoPath, chunkPaths);
+        const chunkFiles = chunkPaths
+            .filter((p) => chunkContents.has(p))
+            .map((p) => ({ path: p, content: chunkContents.get(p) }));
+        astCache = createASTCache(chunkFiles.length);
+        const sequentialHeritage = await extractExtractedHeritageFromFiles(chunkFiles, astCache);
+        mergeImplementorMaps(sequentialImplementorMap, buildImplementorMap(sequentialHeritage, ctx));
+        const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, exportedTypeMap, undefined, undefined, undefined, sequentialImplementorMap);
+        await processHeritage(graph, chunkFiles, astCache, ctx);
+        if (rubyHeritage.length > 0) {
+            await processHeritageFromExtracted(graph, rubyHeritage, ctx);
+        }
+        // Extract fetch() calls for Next.js route matching (sequential path)
+        const chunkFetchCalls = await extractFetchCallsFromFiles(chunkFiles, astCache);
+        if (chunkFetchCalls.length > 0) {
+            allFetchCalls.push(...chunkFetchCalls);
+        }
+        // Extract ORM queries (sequential path)
+        for (const f of chunkFiles) {
+            extractORMQueriesInline(f.path, f.content, allORMQueries);
+        }
+        astCache.clear();
+    }
+    // Log resolution cache stats
+    if (isDev) {
+        const rcStats = ctx.getStats();
+        const total = rcStats.cacheHits + rcStats.cacheMisses;
+        const hitRate = total > 0 ? ((rcStats.cacheHits / total) * 100).toFixed(1) : '0';
+        console.log(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`);
+    }
+    // ── Worker path quality enrichment: merge TypeEnv file-scope bindings into ExportedTypeMap ──
+    // Workers return file-scope bindings from their TypeEnv fixpoint (includes inferred types
+    // like `const config = getConfig()` → Config). Filter by graph isExported to match
+    // the sequential path's collectExportedBindings behavior.
+    if (workerTypeEnvBindings.length > 0) {
+        let enriched = 0;
+        for (const { filePath, bindings } of workerTypeEnvBindings) {
+            for (const [name, type] of bindings) {
+                // Verify the symbol is exported via graph node
+                const nodeId = `Function:${filePath}:${name}`;
+                const varNodeId = `Variable:${filePath}:${name}`;
+                const constNodeId = `Const:${filePath}:${name}`;
+                const node = graph.getNode(nodeId) ?? graph.getNode(varNodeId) ?? graph.getNode(constNodeId);
+                if (!node?.properties?.isExported)
+                    continue;
+                let fileExports = exportedTypeMap.get(filePath);
+                if (!fileExports) {
+                    fileExports = new Map();
+                    exportedTypeMap.set(filePath, fileExports);
+                }
+                // Don't overwrite existing entries (Tier 0 from SymbolTable is authoritative)
+                if (!fileExports.has(name)) {
+                    fileExports.set(name, type);
+                    enriched++;
+                }
+            }
+        }
+        if (isDev && enriched > 0) {
+            console.log(`🔗 Worker TypeEnv enrichment: ${enriched} fixpoint-inferred exports added to ExportedTypeMap`);
+        }
+    }
+    // ── Final synthesis pass for whole-module-import languages ──
+    // Per-chunk synthesis (above) already ran incrementally. This final pass ensures
+    // any remaining files whose imports were not covered inline are also synthesized,
+    // and that Phase 14 type propagation has complete namedImportMap data.
+    const synthesized = synthesizeWildcardImportBindings(graph, ctx);
+    if (isDev && synthesized > 0) {
+        console.log(`🔗 Synthesized ${synthesized} additional wildcard import bindings (Go/Ruby/C++/Swift/Python)`);
+    }
+    // Free import resolution context — suffix index + resolve cache no longer needed
+    // (allPathObjects and importCtx hold ~94MB+ for large repos)
+    allPathObjects.length = 0;
+    importCtx.resolveCache.clear();
+    importCtx.index = EMPTY_INDEX; // Release suffix index memory (~30MB for large repos)
+    importCtx.normalizedFileList = [];
+    return {
+        exportedTypeMap,
+        allFetchCalls,
+        allExtractedRoutes,
+        allDecoratorRoutes,
+        allToolDefs,
+        allORMQueries,
+    };
+}
+/**
+ * Post-parse graph analysis: MRO, community detection, process extraction.
+ *
+ * @reads  graph (all nodes and relationships from parse + resolve phases)
+ * @writes graph (Community nodes, Process nodes, MEMBER_OF edges, STEP_IN_PROCESS edges, METHOD_OVERRIDES edges)
+ */
+async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegistry, toolDefs) {
+    // ── Phase 4.5: Method Resolution Order ──────────────────────────────
+    onProgress({
+        phase: 'parsing',
+        percent: 81,
+        message: 'Computing method resolution order...',
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    const mroResult = computeMRO(graph);
+    if (isDev && mroResult.entries.length > 0) {
+        console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities, ${mroResult.overrideEdges} METHOD_OVERRIDES, ${mroResult.methodImplementsEdges} METHOD_IMPLEMENTS`);
+    }
+    // ── Phase 5: Communities ───────────────────────────────────────────
+    onProgress({
+        phase: 'communities',
+        percent: 82,
+        message: 'Detecting code communities...',
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    const communityResult = await processCommunities(graph, (message, progress) => {
+        const communityProgress = 82 + progress * 0.1;
+        onProgress({
+            phase: 'communities',
+            percent: Math.round(communityProgress),
+            message,
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+    });
+    if (isDev) {
+        console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
+    }
+    communityResult.communities.forEach((comm) => {
+        graph.addNode({
+            id: comm.id,
+            label: 'Community',
+            properties: {
+                name: comm.label,
+                filePath: '',
+                heuristicLabel: comm.heuristicLabel,
+                cohesion: comm.cohesion,
+                symbolCount: comm.symbolCount,
+            },
+        });
+    });
+    communityResult.memberships.forEach((membership) => {
+        graph.addRelationship({
+            id: `${membership.nodeId}_member_of_${membership.communityId}`,
+            type: 'MEMBER_OF',
+            sourceId: membership.nodeId,
+            targetId: membership.communityId,
+            confidence: 1.0,
+            reason: 'leiden-algorithm',
+        });
+    });
+    // ── Phase 6: Processes ─────────────────────────────────────────────
+    onProgress({
+        phase: 'processes',
+        percent: 94,
+        message: 'Detecting execution flows...',
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    let symbolCount = 0;
+    graph.forEachNode((n) => {
+        if (n.label !== 'File')
+            symbolCount++;
+    });
+    const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
+    const processResult = await processProcesses(graph, communityResult.memberships, (message, progress) => {
+        const processProgress = 94 + progress * 0.05;
+        onProgress({
+            phase: 'processes',
+            percent: Math.round(processProgress),
+            message,
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+    }, { maxProcesses: dynamicMaxProcesses, minSteps: 3 });
+    if (isDev) {
+        console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
+    }
+    processResult.processes.forEach((proc) => {
+        graph.addNode({
+            id: proc.id,
+            label: 'Process',
+            properties: {
+                name: proc.label,
+                filePath: '',
+                heuristicLabel: proc.heuristicLabel,
+                processType: proc.processType,
+                stepCount: proc.stepCount,
+                communities: proc.communities,
+                entryPointId: proc.entryPointId,
+                terminalId: proc.terminalId,
+            },
+        });
+    });
+    processResult.steps.forEach((step) => {
+        graph.addRelationship({
+            id: `${step.nodeId}_step_${step.step}_${step.processId}`,
+            type: 'STEP_IN_PROCESS',
+            sourceId: step.nodeId,
+            targetId: step.processId,
+            confidence: 1.0,
+            reason: 'trace-detection',
+            step: step.step,
+        });
+    });
+    // Link Route and Tool nodes to Processes via reverse index (file → node id)
+    if ((routeRegistry?.size ?? 0) > 0 || (toolDefs?.length ?? 0) > 0) {
+        // Reverse indexes: file → all route URLs / tool names (handles multi-route files)
+        const routesByFile = new Map();
+        if (routeRegistry) {
+            for (const [url, entry] of routeRegistry) {
+                let list = routesByFile.get(entry.filePath);
+                if (!list) {
+                    list = [];
+                    routesByFile.set(entry.filePath, list);
+                }
+                list.push(url);
+            }
+        }
+        const toolsByFile = new Map();
+        if (toolDefs) {
+            for (const td of toolDefs) {
+                let list = toolsByFile.get(td.filePath);
+                if (!list) {
+                    list = [];
+                    toolsByFile.set(td.filePath, list);
+                }
+                list.push(td.name);
+            }
+        }
+        let linked = 0;
+        for (const proc of processResult.processes) {
+            if (!proc.entryPointId)
+                continue;
+            const entryNode = graph.getNode(proc.entryPointId);
+            if (!entryNode)
+                continue;
+            const entryFile = entryNode.properties.filePath;
+            if (!entryFile)
+                continue;
+            const routeURLs = routesByFile.get(entryFile);
+            if (routeURLs) {
+                for (const routeURL of routeURLs) {
+                    const routeNodeId = generateId('Route', routeURL);
+                    graph.addRelationship({
+                        id: generateId('ENTRY_POINT_OF', `${routeNodeId}->${proc.id}`),
+                        sourceId: routeNodeId,
+                        targetId: proc.id,
+                        type: 'ENTRY_POINT_OF',
+                        confidence: 0.85,
+                        reason: 'route-handler-entry-point',
+                    });
+                    linked++;
+                }
+            }
+            const toolNames = toolsByFile.get(entryFile);
+            if (toolNames) {
+                for (const toolName of toolNames) {
+                    const toolNodeId = generateId('Tool', toolName);
+                    graph.addRelationship({
+                        id: generateId('ENTRY_POINT_OF', `${toolNodeId}->${proc.id}`),
+                        sourceId: toolNodeId,
+                        targetId: proc.id,
+                        type: 'ENTRY_POINT_OF',
+                        confidence: 0.85,
+                        reason: 'tool-handler-entry-point',
+                    });
+                    linked++;
+                }
+            }
+        }
+        if (isDev && linked > 0) {
+            console.log(`🔗 Linked ${linked} Route/Tool nodes to execution flows`);
+        }
+    }
+    return { communityResult, processResult };
+}
+// ── Pipeline orchestrator ─────────────────────────────────────────────────
+export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
+    const graph = createKnowledgeGraph();
+    const ctx = createResolutionContext();
+    const pipelineStart = Date.now();
+    try {
+        // Phase 1+2: Scan paths, build structure, process markdown
+        const { scannedFiles, allPaths, totalFiles } = await runScanAndStructure(repoPath, graph, onProgress);
+        // Phase 3+4: Chunked parse + resolve (imports, calls, heritage, routes)
+        const { exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes, allToolDefs, allORMQueries, } = await runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress);
+        const routeRegistry = new Map();
+        // Detect Expo Router app/ roots vs Next.js app/ roots (monorepo-safe).
+        const expoAppRoots = new Set();
+        const nextjsAppRoots = new Set();
+        const expoAppPaths = new Set();
+        for (const p of allPaths) {
+            const norm = p.replace(/\\/g, '/');
+            const appIdx = norm.lastIndexOf('app/');
+            if (appIdx < 0)
+                continue;
+            const root = norm.slice(0, appIdx + 4);
+            if (/\/_layout\.(tsx?|jsx?)$/.test(norm))
+                expoAppRoots.add(root);
+            if (/\/page\.(tsx?|jsx?)$/.test(norm))
+                nextjsAppRoots.add(root);
+        }
+        for (const root of nextjsAppRoots)
+            expoAppRoots.delete(root);
+        if (expoAppRoots.size > 0) {
+            for (const p of allPaths) {
+                const norm = p.replace(/\\/g, '/');
+                const appIdx = norm.lastIndexOf('app/');
+                if (appIdx >= 0 && expoAppRoots.has(norm.slice(0, appIdx + 4)))
+                    expoAppPaths.add(p);
+            }
+        }
+        for (const p of allPaths) {
+            if (expoAppPaths.has(p)) {
+                const expoURL = expoFileToRouteURL(p);
+                if (expoURL && !routeRegistry.has(expoURL)) {
+                    routeRegistry.set(expoURL, { filePath: p, source: 'expo-filesystem-route' });
+                    continue;
+                }
+            }
+            const nextjsURL = nextjsFileToRouteURL(p);
+            if (nextjsURL && !routeRegistry.has(nextjsURL)) {
+                routeRegistry.set(nextjsURL, { filePath: p, source: 'nextjs-filesystem-route' });
+                continue;
+            }
+            if (p.endsWith('.php')) {
+                const phpURL = phpFileToRouteURL(p);
+                if (phpURL && !routeRegistry.has(phpURL)) {
+                    routeRegistry.set(phpURL, { filePath: p, source: 'php-file-route' });
+                }
+            }
+        }
+        const ensureSlash = (path) => (path.startsWith('/') ? path : '/' + path);
+        let duplicateRoutes = 0;
+        const addRoute = (url, entry) => {
+            if (routeRegistry.has(url)) {
+                duplicateRoutes++;
+                return;
+            }
+            routeRegistry.set(url, entry);
+        };
+        for (const route of allExtractedRoutes) {
+            if (!route.routePath)
+                continue;
+            addRoute(ensureSlash(route.routePath), {
+                filePath: route.filePath,
+                source: 'framework-route',
+            });
+        }
+        for (const dr of allDecoratorRoutes) {
+            addRoute(ensureSlash(dr.routePath), {
+                filePath: dr.filePath,
+                source: `decorator-${dr.decoratorName}`,
+            });
+        }
+        let handlerContents;
+        if (routeRegistry.size > 0) {
+            const handlerPaths = [...routeRegistry.values()].map((e) => e.filePath);
+            handlerContents = await readFileContents(repoPath, handlerPaths);
+            for (const [routeURL, entry] of routeRegistry) {
+                const { filePath: handlerPath, source: routeSource } = entry;
+                const content = handlerContents.get(handlerPath);
+                const { responseKeys, errorKeys } = content
+                    ? handlerPath.endsWith('.php')
+                        ? extractPHPResponseShapes(content)
+                        : extractResponseShapes(content)
+                    : { responseKeys: undefined, errorKeys: undefined };
+                const mwResult = content ? extractMiddlewareChain(content) : undefined;
+                const middleware = mwResult?.chain;
+                const routeNodeId = generateId('Route', routeURL);
+                graph.addNode({
+                    id: routeNodeId,
+                    label: 'Route',
+                    properties: {
+                        name: routeURL,
+                        filePath: handlerPath,
+                        ...(responseKeys ? { responseKeys } : {}),
+                        ...(errorKeys ? { errorKeys } : {}),
+                        ...(middleware && middleware.length > 0 ? { middleware } : {}),
+                    },
+                });
+                const handlerFileId = generateId('File', handlerPath);
+                graph.addRelationship({
+                    id: generateId('HANDLES_ROUTE', `${handlerFileId}->${routeNodeId}`),
+                    sourceId: handlerFileId,
+                    targetId: routeNodeId,
+                    type: 'HANDLES_ROUTE',
+                    confidence: 1.0,
+                    reason: routeSource,
+                });
+            }
+            if (isDev) {
+                console.log(`🗺️ Route registry: ${routeRegistry.size} routes${duplicateRoutes > 0 ? ` (${duplicateRoutes} duplicate URLs skipped)` : ''}`);
+            }
+        }
+        // ── Phase 3.5b: Link Next.js project-level middleware.ts to routes ──
+        if (routeRegistry.size > 0) {
+            const middlewareCandidates = allPaths.filter((p) => p === 'middleware.ts' ||
+                p === 'middleware.js' ||
+                p === 'middleware.tsx' ||
+                p === 'middleware.jsx' ||
+                p === 'src/middleware.ts' ||
+                p === 'src/middleware.js' ||
+                p === 'src/middleware.tsx' ||
+                p === 'src/middleware.jsx');
+            if (middlewareCandidates.length > 0) {
+                const mwContents = await readFileContents(repoPath, middlewareCandidates);
+                for (const [mwPath, mwContent] of mwContents) {
+                    const config = extractNextjsMiddlewareConfig(mwContent);
+                    if (!config)
+                        continue;
+                    const mwLabel = config.wrappedFunctions.length > 0 ? config.wrappedFunctions : [config.exportedName];
+                    // Pre-compile matchers once per middleware file
+                    const compiled = config.matchers
+                        .map(compileMatcher)
+                        .filter((m) => m !== null);
+                    let linkedCount = 0;
+                    for (const [routeURL] of routeRegistry) {
+                        const matches = compiled.length === 0 ||
+                            compiled.some((cm) => compiledMatcherMatchesRoute(cm, routeURL));
+                        if (!matches)
+                            continue;
+                        const routeNodeId = generateId('Route', routeURL);
+                        const existing = graph.getNode(routeNodeId);
+                        if (!existing)
+                            continue;
+                        const currentMw = existing.properties.middleware ?? [];
+                        // Prepend project-level middleware (runs before handler-level wrappers)
+                        existing.properties.middleware = [
+                            ...mwLabel,
+                            ...currentMw.filter((m) => !mwLabel.includes(m)),
+                        ];
+                        linkedCount++;
+                    }
+                    if (isDev && linkedCount > 0) {
+                        console.log(`🛡️ Linked ${mwPath} middleware [${mwLabel.join(', ')}] to ${linkedCount} routes`);
+                    }
+                }
+            }
+        }
+        // Scan HTML/PHP/template files for <form action="/path"> and AJAX url patterns
+        // Scan HTML/template files for <form action="/path"> and AJAX url patterns
+        // Skip .php — already parsed by tree-sitter with http_client/fetch queries
+        const htmlCandidates = allPaths.filter((p) => p.endsWith('.html') ||
+            p.endsWith('.htm') ||
+            p.endsWith('.ejs') ||
+            p.endsWith('.hbs') ||
+            p.endsWith('.blade.php'));
+        if (htmlCandidates.length > 0 && routeRegistry.size > 0) {
+            const htmlContents = await readFileContents(repoPath, htmlCandidates);
+            const htmlPatterns = [/action=["']([^"']+)["']/g, /url:\s*["']([^"']+)["']/g];
+            for (const [filePath, content] of htmlContents) {
+                for (const pattern of htmlPatterns) {
+                    pattern.lastIndex = 0;
+                    let match;
+                    while ((match = pattern.exec(content)) !== null) {
+                        const normalized = normalizeFetchURL(match[1]);
+                        if (normalized) {
+                            allFetchCalls.push({ filePath, fetchURL: normalized, lineNumber: 0 });
+                        }
+                    }
+                }
+            }
+        }
+        // ── Phase 3.5c: Extract Expo Router navigation patterns ──
+        if (expoAppPaths.size > 0 && routeRegistry.size > 0) {
+            const unreadExpoPaths = [...expoAppPaths].filter((p) => !handlerContents?.has(p));
+            const extraContents = unreadExpoPaths.length > 0
+                ? await readFileContents(repoPath, unreadExpoPaths)
+                : new Map();
+            const allExpoContents = new Map([...(handlerContents ?? new Map()), ...extraContents]);
+            for (const [filePath, content] of allExpoContents) {
+                if (!expoAppPaths.has(filePath))
+                    continue;
+                for (const pattern of EXPO_NAV_PATTERNS) {
+                    pattern.lastIndex = 0;
+                    let match;
+                    while ((match = pattern.exec(content)) !== null) {
+                        const url = match[2] ?? match[1];
+                        if (url && url.startsWith('/')) {
+                            allFetchCalls.push({ filePath, fetchURL: url, lineNumber: 0 });
+                        }
+                    }
+                }
+            }
+        }
+        if (routeRegistry.size > 0 && allFetchCalls.length > 0) {
+            const routeURLToFile = new Map();
+            for (const [url, entry] of routeRegistry)
+                routeURLToFile.set(url, entry.filePath);
+            // Read consumer file contents so we can extract property access patterns
+            const consumerPaths = [...new Set(allFetchCalls.map((c) => c.filePath))];
+            const consumerContents = await readFileContents(repoPath, consumerPaths);
+            processNextjsFetchRoutes(graph, allFetchCalls, routeURLToFile, consumerContents);
+            if (isDev) {
+                console.log(`🔗 Processed ${allFetchCalls.length} fetch() calls against ${routeRegistry.size} routes`);
+            }
+        }
+        // ── Phase 3.6: Tool Detection (MCP/RPC) ──────────────────────────
+        const toolDefs = [];
+        const seenToolNames = new Set();
+        for (const td of allToolDefs) {
+            if (seenToolNames.has(td.toolName))
+                continue;
+            seenToolNames.add(td.toolName);
+            toolDefs.push({ name: td.toolName, filePath: td.filePath, description: td.description });
+        }
+        // TS tool definition arrays — require inputSchema nearby to distinguish from config objects
+        const toolCandidatePaths = allPaths.filter((p) => (p.endsWith('.ts') || p.endsWith('.js')) &&
+            p.toLowerCase().includes('tool') &&
+            !p.includes('node_modules') &&
+            !p.includes('test') &&
+            !p.includes('__'));
+        if (toolCandidatePaths.length > 0) {
+            const toolContents = await readFileContents(repoPath, toolCandidatePaths);
+            for (const [filePath, content] of toolContents) {
+                // Only scan files that contain 'inputSchema' — this is the MCP tool signature
+                if (!content.includes('inputSchema'))
+                    continue;
+                const toolPattern = /name:\s*['"](\w+)['"]\s*,\s*\n?\s*description:\s*[`'"]([\s\S]*?)[`'"]/g;
+                let match;
+                while ((match = toolPattern.exec(content)) !== null) {
+                    const name = match[1];
+                    if (seenToolNames.has(name))
+                        continue;
+                    seenToolNames.add(name);
+                    toolDefs.push({
+                        name,
+                        filePath,
+                        description: match[2].slice(0, 200).replace(/\n/g, ' ').trim(),
+                    });
+                }
+            }
+        }
+        // Create Tool nodes and HANDLES_TOOL edges
+        if (toolDefs.length > 0) {
+            for (const td of toolDefs) {
+                const toolNodeId = generateId('Tool', td.name);
+                graph.addNode({
+                    id: toolNodeId,
+                    label: 'Tool',
+                    properties: { name: td.name, filePath: td.filePath, description: td.description },
+                });
+                const handlerFileId = generateId('File', td.filePath);
+                graph.addRelationship({
+                    id: generateId('HANDLES_TOOL', `${handlerFileId}->${toolNodeId}`),
+                    sourceId: handlerFileId,
+                    targetId: toolNodeId,
+                    type: 'HANDLES_TOOL',
+                    confidence: 1.0,
+                    reason: 'tool-definition',
+                });
+            }
+            if (isDev) {
+                console.log(`🔧 Tool registry: ${toolDefs.length} tools detected`);
+            }
+        }
+        // ── Phase 3.7: ORM Dataflow Detection (Prisma + Supabase) ──────────
+        if (allORMQueries.length > 0) {
+            processORMQueries(graph, allORMQueries, isDev);
+        }
+        // ── Phase 14: Cross-file binding propagation (topological level sort) ──
+        await runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPaths, totalFiles, repoPath, pipelineStart, onProgress);
+        // Post-parse graph analysis (MRO, communities, processes)
+        let communityResult;
+        let processResult;
+        if (!options?.skipGraphPhases) {
+            const graphResults = await runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegistry, toolDefs);
+            communityResult = graphResults.communityResult;
+            processResult = graphResults.processResult;
+        }
+        onProgress({
+            phase: 'complete',
+            percent: 100,
+            message: communityResult && processResult
+                ? `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`
+                : 'Graph complete! (graph phases skipped)',
+            stats: {
+                filesProcessed: totalFiles,
+                totalFiles,
+                nodesCreated: graph.nodeCount,
+            },
+        });
+        return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult };
+    }
+    catch (error) {
+        ctx.clear();
+        throw error;
+    }
+};
+// Inline ORM regex extraction (avoids importing parse-worker which has worker-only code)
+const PRISMA_QUERY_RE = /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g;
+const SUPABASE_QUERY_RE = /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g;
+function extractORMQueriesInline(filePath, content, out) {
+    const hasPrisma = content.includes('prisma.');
+    const hasSupabase = content.includes('supabase.from');
+    if (!hasPrisma && !hasSupabase)
+        return;
+    if (hasPrisma) {
+        PRISMA_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = PRISMA_QUERY_RE.exec(content)) !== null) {
+            const model = m[1];
+            if (model.startsWith('$'))
+                continue;
+            out.push({
+                filePath,
+                orm: 'prisma',
+                model,
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
+        }
+    }
+    if (hasSupabase) {
+        SUPABASE_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) {
+            out.push({
+                filePath,
+                orm: 'supabase',
+                model: m[1],
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
+        }
+    }
+}
+// ============================================================================
+// ORM Query Processing — creates QUERIES edges from callers to model nodes
+// ============================================================================
+function processORMQueries(graph, queries, isDev) {
+    const modelNodes = new Map();
+    const seenEdges = new Set();
+    let edgesCreated = 0;
+    for (const q of queries) {
+        const modelKey = `${q.orm}:${q.model}`;
+        let modelNodeId = modelNodes.get(modelKey);
+        if (!modelNodeId) {
+            const candidateIds = [
+                generateId('Class', `${q.model}`),
+                generateId('Interface', `${q.model}`),
+                generateId('CodeElement', `${q.model}`),
+            ];
+            const existing = candidateIds.find((id) => graph.getNode(id));
+            if (existing) {
+                modelNodeId = existing;
+            }
+            else {
+                modelNodeId = generateId('CodeElement', `${q.orm}:${q.model}`);
+                graph.addNode({
+                    id: modelNodeId,
+                    label: 'CodeElement',
+                    properties: {
+                        name: q.model,
+                        filePath: '',
+                        description: `${q.orm} model/table: ${q.model}`,
+                    },
+                });
+            }
+            modelNodes.set(modelKey, modelNodeId);
+        }
+        const fileId = generateId('File', q.filePath);
+        const edgeKey = `${fileId}->${modelNodeId}:${q.method}`;
+        if (seenEdges.has(edgeKey))
+            continue;
+        seenEdges.add(edgeKey);
+        graph.addRelationship({
+            id: generateId('QUERIES', edgeKey),
+            sourceId: fileId,
+            targetId: modelNodeId,
+            type: 'QUERIES',
+            confidence: 0.9,
+            reason: `${q.orm}-${q.method}`,
+        });
+        edgesCreated++;
+    }
+    if (isDev) {
+        console.log(`ORM dataflow: ${edgesCreated} QUERIES edges, ${modelNodes.size} models (${queries.length} total calls)`);
+    }
+}
+//# sourceMappingURL=pipeline.js.map