code-graph-context 2.0.0 → 2.2.0

package/dist/core/parsers/typescript-parser.js

@@ -1,36 +1,18 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import crypto from 'crypto';
 import fs from 'fs/promises';
 import path from 'node:path';
 import { glob } from 'glob';
 import { minimatch } from 'minimatch';
 import { Project, Node } from 'ts-morph';
-import { createFrameworkEdgeData } from '../utils/edge-factory.js';
-/**
- * Generate a deterministic node ID based on stable properties.
- * This ensures the same node gets the same ID across reparses.
- *
- * Identity is based on: projectId + coreType + filePath + name (+ parentId for nested nodes)
- * This is stable because when it matters (one side of edge not reparsed),
- * names are guaranteed unchanged (or imports would break, triggering reparse).
- *
- * Including projectId ensures nodes from different projects have unique IDs
- * even if they have identical file paths and names.
- */
-const generateDeterministicId = (projectId, coreType, filePath, name, parentId) => {
-    const parts = parentId ? [projectId, coreType, filePath, parentId, name] : [projectId, coreType, filePath, name];
-    const identity = parts.join('::');
-    const hash = crypto.createHash('sha256').update(identity).digest('hex').substring(0, 16);
-    return `${projectId}:${coreType}:${hash}`;
-};
-import { debugLog, hashFile } from '../utils/file-utils.js';
+import { EXCLUDE_PATTERNS_GLOB, BUILT_IN_FUNCTIONS, BUILT_IN_METHODS, BUILT_IN_CLASSES } from '../../constants.js';
 import { NESTJS_FRAMEWORK_SCHEMA } from '../config/nestjs-framework-schema.js';
 import { CoreNodeType, CORE_TYPESCRIPT_SCHEMA, DEFAULT_PARSE_OPTIONS, CoreEdgeType, } from '../config/schema.js';
+import { normalizeCode } from '../utils/code-normalizer.js';
+import { debugLog, hashFile, matchesPattern, cleanTypeName } from '../utils/file-utils.js';
+import { createFrameworkEdgeData, createCoreEdge as createCoreEdgeFactory, createCallsEdge as createCallsEdgeFactory, toNeo4jNode, toNeo4jEdge, toParsedEdge, generateDeterministicId, } from '../utils/graph-factory.js';
 import { resolveProjectId } from '../utils/project-id.js';
 export class TypeScriptParser {
-    workspacePath;
-    tsConfigPath;
-    project;
+    project; // initialized in constructor, undefined in resolver-only mode
     coreSchema;
     parseConfig;
     frameworkSchemas;
@@ -43,17 +25,50 @@ export class TypeScriptParser {
     lazyLoad; // Whether to use lazy file loading for large projects
     discoveredFiles = null; // Cached file discovery results
     deferEdgeEnhancements = false; // When true, skip edge enhancements (parent will handle)
+    // Lookup indexes for efficient CALLS edge resolution
+    methodsByClass = new Map(); // className -> methodName -> node
+    functionsByName = new Map(); // functionName -> node
+    constructorsByClass = new Map(); // className -> constructor node
+    // Track already exported items to avoid returning duplicates in streaming mode
+    exportedNodeIds = new Set();
+    exportedEdgeIds = new Set();
+    workspacePath;
+    /**
+     * Create a resolver-only instance for edge resolution without parsing.
+     * This mode doesn't initialize ts-morph and can only resolve edges from externally-added nodes.
+     */
+    static createResolver(projectId) {
+        const instance = Object.create(TypeScriptParser.prototype);
+        // project is intentionally not initialized - resolver mode doesn't need ts-morph
+        instance.coreSchema = CORE_TYPESCRIPT_SCHEMA;
+        instance.parseConfig = DEFAULT_PARSE_OPTIONS;
+        instance.frameworkSchemas = [];
+        instance.parsedNodes = new Map();
+        instance.parsedEdges = new Map();
+        instance.existingNodes = new Map();
+        instance.deferredEdges = [];
+        instance.sharedContext = new Map();
+        instance.projectId = projectId;
+        instance.lazyLoad = true;
+        instance.discoveredFiles = null;
+        instance.deferEdgeEnhancements = false;
+        instance.methodsByClass = new Map();
+        instance.functionsByName = new Map();
+        instance.constructorsByClass = new Map();
+        instance.exportedNodeIds = new Set();
+        instance.exportedEdgeIds = new Set();
+        instance.workspacePath = '';
+        return instance;
+    }
     constructor(workspacePath, tsConfigPath = 'tsconfig.json', coreSchema = CORE_TYPESCRIPT_SCHEMA, frameworkSchemas = [NESTJS_FRAMEWORK_SCHEMA], parseConfig = DEFAULT_PARSE_OPTIONS, projectId, // Optional - derived from workspacePath if not provided
     lazyLoad = false) {
         this.workspacePath = workspacePath;
-        this.tsConfigPath = tsConfigPath;
         this.coreSchema = coreSchema;
         this.frameworkSchemas = frameworkSchemas;
         this.parseConfig = parseConfig;
         this.projectId = resolveProjectId(workspacePath, projectId);
         this.lazyLoad = lazyLoad;
-        console.log(`🆔 Project ID: ${this.projectId}`);
-        console.log(`📂 Lazy loading: ${lazyLoad ? 'enabled' : 'disabled'}`);
+        debugLog('Parser initialized', { projectId: this.projectId, lazyLoad });
         if (lazyLoad) {
             // Lazy mode: create Project without loading any files
             // Files will be added just-in-time during parseChunk()
@@ -97,6 +112,35 @@ export class TypeScriptParser {
     getProjectId() {
         return this.projectId;
     }
+    /**
+     * Get all parsed nodes (for cross-parser edge resolution).
+     * Returns the internal Map of ParsedNodes.
+     */
+    getParsedNodes() {
+        return this.parsedNodes;
+    }
+    /**
+     * Get the framework schemas used by this parser.
+     * Useful for WorkspaceParser to apply cross-package edge enhancements.
+     */
+    getFrameworkSchemas() {
+        return this.frameworkSchemas;
+    }
+    /**
+     * Get the shared context from this parser.
+     * Useful for aggregating context across multiple parsers.
+     */
+    getSharedContext() {
+        return this.sharedContext;
+    }
+    /**
+     * Set the shared context for this parser.
+     * Use this to share context across multiple parsers (e.g., in WorkspaceParser).
+     * @param context The shared context map to use
+     */
+    setSharedContext(context) {
+        this.sharedContext = context;
+    }
     /**
      * Set existing nodes from Neo4j for edge target matching during incremental parsing.
      * These nodes will be available as targets for edge detection but won't be exported.
@@ -122,63 +166,204 @@ export class TypeScriptParser {
             };
             this.existingNodes.set(node.id, parsedNode);
         }
-        console.log(`📦 Loaded ${nodes.length} existing nodes for edge detection`);
+        debugLog('Loaded existing nodes for edge detection', { count: nodes.length });
+    }
+    /**
+     * Defer edge enhancements to a parent parser (e.g., WorkspaceParser).
+     * When true, parseChunk() will skip applyEdgeEnhancements().
+     * The parent is responsible for calling applyEdgeEnhancementsManually() at the end.
+     */
+    setDeferEdgeEnhancements(defer) {
+        this.deferEdgeEnhancements = defer;
+    }
+    /**
+     * Load framework schemas for a specific project type.
+     * No-op for TypeScriptParser since schemas are loaded in constructor.
+     */
+    loadFrameworkSchemasForType(_projectType) {
+        // TypeScriptParser already has schemas loaded via constructor/ParserFactory
     }
     async parseWorkspace(filesToParse) {
         let sourceFiles;
+        // Determine which files to parse
+        let filePaths;
         if (filesToParse && filesToParse.length > 0) {
-            // In lazy mode, files may not be loaded yet - add them if needed
-            sourceFiles = filesToParse
-                .map((filePath) => {
-                const existing = this.project.getSourceFile(filePath);
-                if (existing)
-                    return existing;
-                // Add file to project if not already loaded (lazy mode)
-                try {
-                    return this.project.addSourceFileAtPath(filePath);
-                }
-                catch {
-                    return undefined;
-                }
-            })
-                .filter((sf) => sf !== undefined);
+            filePaths = filesToParse;
+        }
+        else if (this.lazyLoad) {
+            // In lazy mode, use glob-based discovery (consistent with detectChangedFiles)
+            filePaths = await this.discoverSourceFiles();
         }
         else {
+            // Eager mode - files already loaded from tsconfig
             sourceFiles = this.project.getSourceFiles();
+            for (const sourceFile of sourceFiles) {
+                if (this.shouldSkipFile(sourceFile))
+                    continue;
+                await this.parseCoreTypeScript(sourceFile);
+            }
+            return this.finishParsing();
         }
+        // Load files into project (for lazy mode or explicit file list)
+        sourceFiles = filePaths
+            .map((filePath) => {
+            const existing = this.project.getSourceFile(filePath);
+            if (existing)
+                return existing;
+            try {
+                return this.project.addSourceFileAtPath(filePath);
+            }
+            catch {
+                return undefined;
+            }
+        })
+            .filter((sf) => sf !== undefined);
         for (const sourceFile of sourceFiles) {
             if (this.shouldSkipFile(sourceFile))
                 continue;
-            await this.parseCoreTypeScriptV2(sourceFile);
-        }
-        await this.resolveDeferredEdges();
-        await this.applyContextExtractors();
-        if (this.frameworkSchemas.length > 0) {
-            await this.applyFrameworkEnhancements();
+            await this.parseCoreTypeScript(sourceFile);
         }
-        await this.applyEdgeEnhancements();
-        const neo4jNodes = Array.from(this.parsedNodes.values()).map(this.toNeo4jNode);
-        const neo4jEdges = Array.from(this.parsedEdges.values()).map(this.toNeo4jEdge);
-        return { nodes: neo4jNodes, edges: neo4jEdges };
+        return this.finishParsing();
     }
     /**
-     * Check if variable declarations should be parsed for this file
-     * based on framework schema configurations
+     * Parse a chunk of files without resolving deferred edges.
+     * Use this for streaming parsing where edges are resolved after all chunks.
+     * In lazy mode, files are added to the project just-in-time and removed after parsing.
+     * @param filePaths Specific file paths to parse
+     * @param skipEdgeResolution If true, deferred edges are not resolved (default: false)
      */
-    shouldParseVariables(filePath) {
-        for (const schema of this.frameworkSchemas) {
-            const parsePatterns = schema.metadata.parseVariablesFrom;
-            if (parsePatterns) {
-                for (const pattern of parsePatterns) {
-                    if (minimatch(filePath, pattern)) {
-                        return true;
+    async parseChunk(filePaths, skipEdgeResolution = false) {
+        // Declare sourceFiles outside try so it's available in finally
+        const sourceFiles = [];
+        try {
+            if (this.lazyLoad) {
+                // Lazy mode: add files to project just-in-time
+                for (const filePath of filePaths) {
+                    try {
+                        // Check if file already exists in project (shouldn't happen in lazy mode)
+                        // Add the file to the project if not already present
+                        const sourceFile = this.project.getSourceFile(filePath) ?? this.project.addSourceFileAtPath(filePath);
+                        sourceFiles.push(sourceFile);
                     }
+                    catch (error) {
+                        console.warn(`Failed to add source file ${filePath}:`, error);
+                    }
+                }
+            }
+            else {
+                // Eager mode: files are already loaded
+                const loadedFiles = filePaths
+                    .map((filePath) => this.project.getSourceFile(filePath))
+                    .filter((sf) => sf !== undefined);
+                sourceFiles.push(...loadedFiles);
+            }
+            for (const sourceFile of sourceFiles) {
+                if (this.shouldSkipFile(sourceFile))
+                    continue;
+                await this.parseCoreTypeScript(sourceFile);
+            }
+            // Only resolve edges if not skipping
+            if (!skipEdgeResolution) {
+                await this.resolveDeferredEdges();
+            }
+            await this.applyContextExtractors();
+            if (this.frameworkSchemas.length > 0) {
+                await this.applyFrameworkEnhancements();
+            }
+            // Apply edge enhancements unless deferred to parent (e.g., WorkspaceParser)
+            // When deferred, parent will call applyEdgeEnhancementsManually() at the end
+            // with all accumulated nodes for cross-package edge detection
+            if (!this.deferEdgeEnhancements) {
+                await this.applyEdgeEnhancements();
+            }
+            // Only return nodes/edges that haven't been exported yet (prevents duplicate imports in streaming mode)
+            const newNodes = [];
+            const newEdges = [];
+            for (const node of this.parsedNodes.values()) {
+                if (!this.exportedNodeIds.has(node.id)) {
+                    newNodes.push(toNeo4jNode(node));
+                    this.exportedNodeIds.add(node.id);
+                }
+            }
+            for (const edge of this.parsedEdges.values()) {
+                if (!this.exportedEdgeIds.has(edge.id)) {
+                    newEdges.push(toNeo4jEdge(edge));
+                    this.exportedEdgeIds.add(edge.id);
                 }
             }
+            return { nodes: newNodes, edges: newEdges };
         }
-        return false;
+        finally {
+            // Always clean up in lazy mode to prevent memory leaks
+            if (this.lazyLoad) {
+                for (const sourceFile of sourceFiles) {
+                    try {
+                        this.project.removeSourceFile(sourceFile);
+                    }
+                    catch {
+                        // Ignore errors when removing files
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Get list of source files in the project.
+     * In lazy mode, uses glob to discover files without loading them into memory.
+     * Useful for determining total work and creating chunks.
+     */
+    async discoverSourceFiles() {
+        if (this.discoveredFiles !== null) {
+            return this.discoveredFiles;
+        }
+        if (this.lazyLoad) {
+            // Use glob to find files without loading them into ts-morph
+            // Use EXCLUDE_PATTERNS_GLOB for consistency with detectChangedFiles
+            const pattern = path.join(this.workspacePath, '**/*.{ts,tsx}');
+            this.discoveredFiles = await glob(pattern, {
+                ignore: EXCLUDE_PATTERNS_GLOB,
+                absolute: true,
+            });
+            debugLog('Discovered TypeScript files (lazy mode)', { count: this.discoveredFiles.length });
+            return this.discoveredFiles;
+        }
+        else {
+            // Eager mode - files are already loaded
+            this.discoveredFiles = this.project
+                .getSourceFiles()
+                .filter((sf) => !this.shouldSkipFile(sf))
+                .map((sf) => sf.getFilePath());
+            return this.discoveredFiles;
+        }
+    }
+    /**
+     * @deprecated Use discoverSourceFiles() instead for async file discovery
+     */
+    getSourceFilePaths() {
+        if (this.lazyLoad) {
+            throw new Error('getSourceFilePaths() is not supported in lazy mode. Use discoverSourceFiles() instead.');
+        }
+        return this.project
+            .getSourceFiles()
+            .filter((sf) => !this.shouldSkipFile(sf))
+            .map((sf) => sf.getFilePath());
+    }
+    /**
+     * Complete parsing by resolving edges and applying enhancements.
+     * Called after all source files have been parsed.
+     */
+    async finishParsing() {
+        await this.resolveDeferredEdges();
+        await this.applyContextExtractors();
+        if (this.frameworkSchemas.length > 0) {
+            await this.applyFrameworkEnhancements();
+        }
+        await this.applyEdgeEnhancements();
+        const neo4jNodes = Array.from(this.parsedNodes.values()).map(toNeo4jNode);
+        const neo4jEdges = Array.from(this.parsedEdges.values()).map(toNeo4jEdge);
+        return { nodes: neo4jNodes, edges: neo4jEdges };
     }
-    async parseCoreTypeScriptV2(sourceFile) {
+    async parseCoreTypeScript(sourceFile) {
         const filePath = sourceFile.getFilePath();
         const stats = await fs.stat(filePath);
         const fileTrackingProperties = {
@@ -221,16 +406,17 @@ export class TypeScriptParser {
                 });
             }
         }
-        if (this.shouldParseVariables(sourceFile.getFilePath())) {
-            for (const varStatement of sourceFile.getVariableStatements()) {
-                for (const varDecl of varStatement.getDeclarations()) {
-                    if (this.shouldSkipChildNode(varDecl))
-                        continue;
-                    const variableNode = this.createCoreNode(varDecl, CoreNodeType.VARIABLE_DECLARATION, {}, sourceFileNode.id);
-                    this.addNode(variableNode);
-                    const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, variableNode.id);
-                    this.addEdge(containsEdge);
-                }
+        for (const varStatement of sourceFile.getVariableStatements()) {
+            const isExported = varStatement.isExported();
+            if (!isExported && !this.shouldParseVariables(sourceFile.getFilePath()))
+                continue;
+            for (const varDecl of varStatement.getDeclarations()) {
+                if (this.shouldSkipChildNode(varDecl))
+                    continue;
+                const variableNode = this.createCoreNode(varDecl, CoreNodeType.VARIABLE_DECLARATION, { isExported }, sourceFileNode.id);
+                this.addNode(variableNode);
+                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, variableNode.id);
+                this.addEdge(containsEdge);
             }
         }
     }
@@ -257,7 +443,15 @@ export class TypeScriptParser {
             for (const child of children) {
                 if (this.shouldSkipChildNode(child))
                     continue;
-                const coreNode = this.createCoreNode(child, type, {}, parentNode.id);
+                // Track parent class name for methods, properties, and constructors
+                const extraProperties = {};
+                if (parentNode.coreType === CoreNodeType.CLASS_DECLARATION &&
+                    (type === CoreNodeType.METHOD_DECLARATION ||
+                        type === CoreNodeType.PROPERTY_DECLARATION ||
+                        type === CoreNodeType.CONSTRUCTOR_DECLARATION)) {
+                    extraProperties.parentClassName = parentNode.properties.name;
+                }
+                const coreNode = this.createCoreNode(child, type, extraProperties, parentNode.id);
                 this.addNode(coreNode);
                 const coreEdge = this.createCoreEdge(edgeType, parentNode.id, coreNode.id);
                 this.addEdge(coreEdge);
@@ -269,6 +463,15 @@ export class TypeScriptParser {
                 if (SKELETONIZE_TYPES.has(type)) {
                     this.skeletonizeChildInParent(parentNode, coreNode);
                 }
+                // Extract CALLS edges from method/function/constructor bodies
+                const CALL_EXTRACTION_TYPES = new Set([
+                    CoreNodeType.METHOD_DECLARATION,
+                    CoreNodeType.FUNCTION_DECLARATION,
+                    CoreNodeType.CONSTRUCTOR_DECLARATION,
+                ]);
+                if (CALL_EXTRACTION_TYPES.has(type)) {
+                    this.extractCallsFromBody(coreNode, child);
+                }
                 const childNodeConfig = this.coreSchema.nodeTypes[type];
                 if (childNodeConfig) {
                     this.queueRelationshipNodes(childNodeConfig, coreNode, child);
@@ -286,87 +489,542 @@ export class TypeScriptParser {
             parent.properties.sourceCode = parent.properties.sourceCode.replace(childText, placeholder);
         }
     }
-    /**
-     * Queue relationship edges for deferred processing
-     * These are resolved after all nodes are parsed since the target may not exist yet
-     */
-    queueRelationshipNodes(nodeConfig, parsedNode, astNode) {
-        if (!nodeConfig.relationships || nodeConfig.relationships.length === 0)
-            return;
-        for (const relationship of nodeConfig.relationships) {
-            const { edgeType, method, cardinality, targetNodeType } = relationship;
-            const astGetter = astNode[method];
-            if (typeof astGetter !== 'function')
-                continue;
-            const result = astGetter.call(astNode);
-            if (!result)
-                continue;
-            const targets = cardinality === 'single' ? [result] : result;
-            for (const target of targets) {
-                if (!target)
-                    continue;
-                const targetName = this.extractRelationshipTargetName(target);
-                if (!targetName)
-                    continue;
-                // For EXTENDS/IMPLEMENTS, try to get the file path from the resolved declaration
-                let targetFilePath;
-                if (edgeType === CoreEdgeType.EXTENDS || edgeType === CoreEdgeType.IMPLEMENTS) {
-                    targetFilePath = this.extractTargetFilePath(target);
-                }
-                this.deferredEdges.push({
-                    edgeType: edgeType,
-                    sourceNodeId: parsedNode.id,
-                    targetName,
-                    targetType: targetNodeType,
-                    targetFilePath,
-                });
-            }
-        }
-    }
-    /**
-     * Extract the file path from a resolved target declaration.
-     * Used for EXTENDS/IMPLEMENTS to enable precise matching.
-     */
-    extractTargetFilePath(target) {
+    extractNodeName(astNode, coreType) {
         try {
-            // If target is already a ClassDeclaration or InterfaceDeclaration, get its source file
-            if (Node.isClassDeclaration(target) || Node.isInterfaceDeclaration(target)) {
-                return target.getSourceFile().getFilePath();
-            }
-            // If target is ExpressionWithTypeArguments (e.g., extends Foo<T>), resolve the type
-            if (Node.isExpressionWithTypeArguments(target)) {
-                const expression = target.getExpression();
-                if (Node.isIdentifier(expression)) {
-                    // Try to get the definition of the type
-                    const definitions = expression.getDefinitionNodes();
-                    for (const def of definitions) {
-                        if (Node.isClassDeclaration(def) || Node.isInterfaceDeclaration(def)) {
-                            return def.getSourceFile().getFilePath();
-                        }
-                    }
-                }
-            }
+            switch (coreType) {
+                case CoreNodeType.SOURCE_FILE:
+                    if (Node.isSourceFile(astNode)) {
+                        return astNode.getBaseName();
+                    }
+                    break;
+                case CoreNodeType.CLASS_DECLARATION:
+                    if (Node.isClassDeclaration(astNode)) {
+                        return astNode.getName() ?? 'AnonymousClass';
+                    }
+                    break;
+                case CoreNodeType.METHOD_DECLARATION:
+                    if (Node.isMethodDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.FUNCTION_DECLARATION:
+                    if (Node.isFunctionDeclaration(astNode)) {
+                        return astNode.getName() ?? 'AnonymousFunction';
+                    }
+                    break;
+                case CoreNodeType.INTERFACE_DECLARATION:
+                    if (Node.isInterfaceDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.PROPERTY_DECLARATION:
+                    if (Node.isPropertyDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.PARAMETER_DECLARATION:
+                    if (Node.isParameterDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.IMPORT_DECLARATION:
+                    if (Node.isImportDeclaration(astNode)) {
+                        return astNode.getModuleSpecifierValue();
+                    }
+                    break;
+                case CoreNodeType.DECORATOR:
+                    if (Node.isDecorator(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                case CoreNodeType.TYPE_ALIAS:
+                    if (Node.isTypeAliasDeclaration(astNode)) {
+                        return astNode.getName();
+                    }
+                    break;
+                default:
+                    return astNode.getKindName();
+            }
+        }
+        catch (error) {
+            console.warn(`Error extracting name for ${coreType}:`, error);
+        }
+        return 'Unknown';
+    }
+    extractProperty(astNode, propDef) {
+        const { method, source, defaultValue } = propDef.extraction;
+        try {
+            switch (method) {
+                case 'ast':
+                    if (typeof source === 'string') {
+                        const fn = astNode[source];
+                        return typeof fn === 'function' ? fn.call(astNode) : defaultValue;
+                    }
+                    return defaultValue;
+                case 'function':
+                    if (typeof source === 'function') {
+                        return source(astNode);
+                    }
+                    return defaultValue;
+                case 'static':
+                    return defaultValue;
+                case 'context':
+                    // Context properties are handled by context extractors
+                    return undefined;
+                default:
+                    return defaultValue;
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to extract property ${propDef.name}:`, error);
+            return defaultValue;
+        }
+    }
+    /**
+     * Extract the target name from an AST node returned by relationship methods
+     */
+    extractRelationshipTargetName(target) {
+        if (Node.isClassDeclaration(target))
+            return target.getName();
+        if (Node.isInterfaceDeclaration(target))
+            return target.getName();
+        if (Node.isExpressionWithTypeArguments(target)) {
+            const expression = target.getExpression();
+            const text = expression.getText();
+            const genericIndex = text.indexOf('<');
+            return genericIndex > 0 ? text.substring(0, genericIndex) : text;
+        }
+        return undefined;
+    }
+    /**
+     * Extract the file path from a resolved target declaration.
+     * Used for EXTENDS/IMPLEMENTS to enable precise matching.
+     */
+    extractTargetFilePath(target) {
+        try {
+            // If target is already a ClassDeclaration or InterfaceDeclaration, get its source file
+            if (Node.isClassDeclaration(target) || Node.isInterfaceDeclaration(target)) {
+                return target.getSourceFile().getFilePath();
+            }
+            // If target is ExpressionWithTypeArguments (e.g., extends Foo<T>), resolve the type
+            if (Node.isExpressionWithTypeArguments(target)) {
+                const expression = target.getExpression();
+                if (Node.isIdentifier(expression)) {
+                    // Try to get the definition of the type
+                    const definitions = expression.getDefinitionNodes();
+                    for (const def of definitions) {
+                        if (Node.isClassDeclaration(def) || Node.isInterfaceDeclaration(def)) {
+                            return def.getSourceFile().getFilePath();
+                        }
+                    }
+                }
+            }
         }
         catch {
             // If resolution fails (e.g., external type), return undefined
         }
-        return undefined;
+        return undefined;
+    }
+    /**
+     * Extract method/function calls from the body of a method or function.
+     * Creates deferred CALLS edges for resolution after all nodes are parsed.
+     */
+    extractCallsFromBody(callerNode, astNode) {
+        // Get the body of the method/function
+        let body;
+        if (Node.isMethodDeclaration(astNode)) {
+            body = astNode.getBody();
+        }
+        else if (Node.isFunctionDeclaration(astNode)) {
+            body = astNode.getBody();
+        }
+        else if (Node.isConstructorDeclaration(astNode)) {
+            body = astNode.getBody();
+        }
+        if (!body)
+            return;
+        // Skip very short method bodies (likely simple getters/setters)
+        const bodyText = body.getText();
+        if (bodyText.length < 15)
+            return;
+        // Track unique calls to avoid duplicates (same method called multiple times)
+        const seenCalls = new Set();
+        // Traverse all descendants looking for call expressions
+        body.forEachDescendant((descendant) => {
+            // Method/function calls: foo(), this.foo(), obj.foo()
+            if (Node.isCallExpression(descendant)) {
+                const callInfo = this.extractCallInfo(descendant, callerNode);
+                if (callInfo) {
+                    const callKey = `${callInfo.targetName}:${callInfo.receiverType ?? 'unknown'}`;
+                    if (!seenCalls.has(callKey)) {
+                        seenCalls.add(callKey);
+                        this.queueCallEdge(callerNode.id, callInfo);
+                    }
+                }
+            }
+            // Constructor calls: new ClassName()
+            if (Node.isNewExpression(descendant)) {
+                const callInfo = this.extractConstructorCallInfo(descendant);
+                if (callInfo) {
+                    const callKey = `constructor:${callInfo.targetClassName}`;
+                    if (!seenCalls.has(callKey)) {
+                        seenCalls.add(callKey);
+                        this.queueCallEdge(callerNode.id, callInfo);
+                    }
+                }
+            }
+        });
+    }
+    /**
+     * Extract call information from a CallExpression.
+     */
+    extractCallInfo(callExpr, callerNode) {
+        if (!Node.isCallExpression(callExpr))
+            return null;
+        const expression = callExpr.getExpression();
+        const lineNumber = callExpr.getStartLineNumber();
+        const argumentCount = callExpr.getArguments().length;
+        // Check if this call is awaited
+        const parent = callExpr.getParent();
+        const isAsync = parent !== undefined && Node.isAwaitExpression(parent);
+        // Case 1: Direct function call - functionName()
+        if (Node.isIdentifier(expression)) {
+            const targetName = expression.getText();
+            // Skip built-in functions and common utilities
+            if (BUILT_IN_FUNCTIONS.has(targetName))
+                return null;
+            return {
+                targetName,
+                targetType: CoreNodeType.FUNCTION_DECLARATION,
+                lineNumber,
+                isAsync,
+                argumentCount,
+            };
+        }
+        // Case 2: Method call - obj.method() or this.method() or this.service.method()
+        if (Node.isPropertyAccessExpression(expression)) {
+            const methodName = expression.getName();
+            const receiver = expression.getExpression();
+            // Skip common built-in method calls
+            if (BUILT_IN_METHODS.has(methodName))
+                return null;
+            // this.method() - internal class method call
+            if (Node.isThisExpression(receiver)) {
+                return {
+                    targetName: methodName,
+                    targetType: CoreNodeType.METHOD_DECLARATION,
+                    receiverExpression: 'this',
+                    lineNumber,
+                    isAsync,
+                    argumentCount,
+                };
+            }
+            // this.service.method() - dependency injection call
+            if (Node.isPropertyAccessExpression(receiver)) {
+                const innerReceiver = receiver.getExpression();
+                if (Node.isThisExpression(innerReceiver)) {
+                    const propertyName = receiver.getName();
+                    // Try to resolve the type from constructor parameters
+                    const receiverType = this.resolvePropertyType(callerNode, propertyName);
+                    return {
+                        targetName: methodName,
+                        targetType: CoreNodeType.METHOD_DECLARATION,
+                        receiverExpression: `this.${propertyName}`,
+                        receiverPropertyName: propertyName,
+                        receiverType,
+                        lineNumber,
+                        isAsync,
+                        argumentCount,
+                    };
+                }
+            }
+            // variable.method() - method call on local variable
+            if (Node.isIdentifier(receiver)) {
+                const varName = receiver.getText();
+                // Try to get the type of the variable
+                let receiverType;
+                try {
+                    const typeText = receiver.getType().getText();
+                    // Clean up type (remove generics, imports)
+                    receiverType = cleanTypeName(typeText);
+                }
+                catch {
+                    // Type resolution failed
+                }
+                return {
+                    targetName: methodName,
+                    targetType: CoreNodeType.METHOD_DECLARATION,
+                    receiverExpression: varName,
+                    receiverType,
+                    lineNumber,
+                    isAsync,
+                    argumentCount,
+                };
+            }
+        }
+        return null;
+    }
+    /**
+     * Extract constructor call information from a NewExpression.
+     */
+    extractConstructorCallInfo(newExpr) {
+        if (!Node.isNewExpression(newExpr))
+            return null;
+        const expression = newExpr.getExpression();
+        const lineNumber = newExpr.getStartLineNumber();
+        const argumentCount = newExpr.getArguments().length;
+        // new ClassName()
+        if (Node.isIdentifier(expression)) {
+            const className = expression.getText();
+            // Skip built-in constructors
+            if (BUILT_IN_CLASSES.has(className))
+                return null;
+            return {
+                targetName: 'constructor',
+                targetType: CoreNodeType.CONSTRUCTOR_DECLARATION,
+                targetClassName: className,
+                lineNumber,
+                isAsync: false,
+                argumentCount,
+            };
+        }
+        return null;
+    }
+    /**
+     * Queue a CALLS edge for deferred resolution.
+     */
+    queueCallEdge(sourceNodeId, callInfo) {
+        // For constructor calls, use class name as target
+        const targetName = callInfo.targetClassName ?? callInfo.targetName;
+        this.deferredEdges.push({
+            edgeType: CoreEdgeType.CALLS,
+            sourceNodeId,
+            targetName,
+            targetType: callInfo.targetType,
+            callContext: {
+                receiverExpression: callInfo.receiverExpression,
+                receiverType: callInfo.receiverType,
+                receiverPropertyName: callInfo.receiverPropertyName,
+                lineNumber: callInfo.lineNumber,
+                isAsync: callInfo.isAsync,
+                argumentCount: callInfo.argumentCount,
+            },
+        });
+    }
+    /**
+     * Resolve the type of a class property from constructor parameters.
+     * Used for NestJS dependency injection pattern.
+     */
+    resolvePropertyType(node, propertyName) {
+        // Look for constructor parameter types in the node's context
+        const context = node.properties.context;
+        if (context?.constructorParamTypes) {
+            const paramTypes = context.constructorParamTypes;
+            // Constructor params with 'private' or 'public' become properties
+            // Try to find a matching parameter by name
+            // The context extractor stores types in order, we need to match by name
+            // For now, use a heuristic: look for type that matches property name
+            for (const paramType of paramTypes) {
+                // Check if the type name matches (case-insensitive, removing 'Service', 'Repository' etc.)
+                const normalizedProp = propertyName.toLowerCase().replace(/service|repository|provider/gi, '');
+                const normalizedType = paramType.toLowerCase().replace(/service|repository|provider/gi, '');
+                if (normalizedType.includes(normalizedProp) || normalizedProp.includes(normalizedType)) {
+                    return paramType;
+                }
+            }
+        }
+        // Also check the class node's parent for constructor info
+        const classNode = this.findParentClassNode(node);
+        if (classNode?.properties.context?.constructorParamTypes) {
+            const paramTypes = classNode.properties.context.constructorParamTypes;
+            for (const paramType of paramTypes) {
+                const normalizedProp = propertyName.toLowerCase().replace(/service|repository|provider/gi, '');
+                const normalizedType = paramType.toLowerCase().replace(/service|repository|provider/gi, '');
+                if (normalizedType.includes(normalizedProp) || normalizedProp.includes(normalizedType)) {
+                    return paramType;
+                }
+            }
+        }
+        return undefined;
+    }
+    createCoreNode(astNode, coreType, baseProperties = {}, parentId) {
+        const name = this.extractNodeName(astNode, coreType);
+        const filePath = astNode.getSourceFile().getFilePath();
+        const nodeId = generateDeterministicId(this.projectId, coreType, filePath, name, parentId);
+        // Extract base properties using schema
+        const properties = {
+            id: nodeId,
+            projectId: this.projectId,
+            name,
+            coreType,
+            filePath,
+            startLine: astNode.getStartLineNumber(),
+            endLine: astNode.getEndLineNumber(),
+            sourceCode: astNode.getText(),
+            createdAt: new Date().toISOString(),
+            ...baseProperties,
+        };
+        // Extract schema-defined properties
+        const coreNodeDef = this.coreSchema.nodeTypes[coreType];
+        if (coreNodeDef) {
+            for (const propDef of coreNodeDef.properties) {
+                try {
+                    const value = this.extractProperty(astNode, propDef);
+                    if (value !== undefined && propDef.name !== 'context') {
+                        properties[propDef.name] = value;
+                    }
+                }
+                catch (error) {
+                    console.warn(`Failed to extract core property ${propDef.name}:`, error);
+                }
+            }
+        }
+        // Compute normalizedHash for duplicate detection (methods, functions, constructors)
+        if (coreType === CoreNodeType.METHOD_DECLARATION ||
+            coreType === CoreNodeType.FUNCTION_DECLARATION ||
+            coreType === CoreNodeType.CONSTRUCTOR_DECLARATION) {
+            try {
+                const { normalizedHash } = normalizeCode(properties.sourceCode);
+                if (normalizedHash) {
+                    properties.normalizedHash = normalizedHash;
+                }
+            }
+            catch (error) {
+                console.warn(`Failed to compute normalizedHash for ${nodeId}:`, error);
+            }
+        }
+        return {
+            id: nodeId,
+            coreType,
+            labels: [...(coreNodeDef?.neo4j.labels || [])],
+            properties,
+            sourceNode: astNode,
+            skipEmbedding: coreNodeDef?.neo4j.skipEmbedding ?? false,
+        };
+    }
+    createCoreEdge(relationshipType, sourceNodeId, targetNodeId) {
+        return toParsedEdge(createCoreEdgeFactory({
+            edgeType: relationshipType,
+            sourceNodeId,
+            targetNodeId,
+            projectId: this.projectId,
+        }));
+    }
+    createCallsEdge(sourceNodeId, targetNodeId, callContext) {
+        return toParsedEdge(createCallsEdgeFactory({
+            sourceNodeId,
+            targetNodeId,
+            projectId: this.projectId,
+            callContext,
+        }));
+    }
+    createFrameworkEdge(semanticType, relationshipType, sourceNodeId, targetNodeId, context = {}, relationshipWeight = 0.5) {
+        const { id, properties } = createFrameworkEdgeData({
+            semanticType,
+            sourceNodeId,
+            targetNodeId,
+            projectId: this.projectId,
+            context,
+            relationshipWeight,
+        });
+        return {
+            id,
+            relationshipType,
+            sourceNodeId,
+            targetNodeId,
+            properties,
+        };
+    }
+    /**
+     * Queue relationship edges for deferred processing
+     * These are resolved after all nodes are parsed since the target may not exist yet
+     */
+    queueRelationshipNodes(nodeConfig, parsedNode, astNode) {
+        if (!nodeConfig.relationships || nodeConfig.relationships.length === 0)
+            return;
+        for (const relationship of nodeConfig.relationships) {
+            const { edgeType, method, cardinality, targetNodeType } = relationship;
+            const astGetter = astNode[method];
+            if (typeof astGetter !== 'function')
+                continue;
+            const result = astGetter.call(astNode);
+            if (!result)
+                continue;
+            const targets = cardinality === 'single' ? [result] : result;
+            for (const target of targets) {
+                if (!target)
+                    continue;
+                const targetName = this.extractRelationshipTargetName(target);
+                if (!targetName)
+                    continue;
+                // For EXTENDS/IMPLEMENTS, try to get the file path from the resolved declaration
+                let targetFilePath;
+                if (edgeType === CoreEdgeType.EXTENDS || edgeType === CoreEdgeType.IMPLEMENTS) {
+                    targetFilePath = this.extractTargetFilePath(target);
+                }
+                this.deferredEdges.push({
+                    edgeType: edgeType,
+                    sourceNodeId: parsedNode.id,
+                    targetName,
+                    targetType: targetNodeType,
+                    targetFilePath,
+                });
+            }
+        }
     }
     /**
-     * Extract the target name from an AST node returned by relationship methods
+     * Resolve the target node for a CALLS edge.
+     * Uses special resolution logic based on call context.
      */
-    extractRelationshipTargetName(target) {
-        if (Node.isClassDeclaration(target))
-            return target.getName();
-        if (Node.isInterfaceDeclaration(target))
-            return target.getName();
-        if (Node.isExpressionWithTypeArguments(target)) {
-            const expression = target.getExpression();
-            const text = expression.getText();
-            const genericIndex = text.indexOf('<');
-            return genericIndex > 0 ? text.substring(0, genericIndex) : text;
+    resolveCallTarget(deferred) {
+        const { targetName, targetType, sourceNodeId, callContext } = deferred;
+        // Case 1: this.method() - internal class method call
+        if (callContext?.receiverExpression === 'this') {
+            // Find the caller's class, then look for method in same class
+            const sourceNode = this.parsedNodes.get(sourceNodeId) ?? this.existingNodes.get(sourceNodeId);
+            if (sourceNode) {
+                const className = this.getClassNameForNode(sourceNode);
+                if (className && this.methodsByClass.has(className)) {
+                    const method = this.methodsByClass.get(className).get(targetName);
+                    if (method)
+                        return method;
+                }
+            }
         }
-        return undefined;
+        // Case 2: this.service.method() - dependency injection call
+        if (callContext?.receiverType) {
+            // Look for method in the receiver's class
+            const className = callContext.receiverType;
+            if (this.methodsByClass.has(className)) {
+                const method = this.methodsByClass.get(className).get(targetName);
+                if (method)
+                    return method;
+            }
+            // Fallback: search all nodes for a method with this name in a class matching the type
+            for (const [, node] of this.parsedNodes) {
+                if (node.coreType === CoreNodeType.METHOD_DECLARATION && node.properties.name === targetName) {
+                    // Check if parent class matches the receiver type
+                    const parentClass = this.findParentClassNode(node);
+                    if (parentClass?.properties.name === className) {
+                        return node;
+                    }
+                }
+            }
+        }
+        // Case 3: Constructor call - find the constructor in the target class
+        if (targetType === CoreNodeType.CONSTRUCTOR_DECLARATION) {
+            const constructor = this.constructorsByClass.get(targetName);
+            if (constructor)
+                return constructor;
+        }
+        // Case 4: Standalone function call
+        if (targetType === CoreNodeType.FUNCTION_DECLARATION) {
+            const func = this.functionsByName.get(targetName);
+            if (func)
+                return func;
+        }
+        // Fallback: generic name matching
+        return this.findNodeByNameAndType(targetName, targetType);
     }
     /**
      * Find a parsed node by name and core type
@@ -464,26 +1122,49 @@ export class TypeScriptParser {
         return undefined;
     }
     /**
-     * Resolve deferred edges after all nodes have been parsed
+     * Resolve deferred edges against both parsed nodes and existing nodes.
+     * Call this after all chunks have been parsed.
+     * @returns Resolved edges
      */
     async resolveDeferredEdges() {
+        const resolvedEdges = [];
         // Count edges by type for logging
         const importsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.IMPORTS).length;
         const extendsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.EXTENDS).length;
         const implementsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.IMPLEMENTS).length;
+        const callsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.CALLS).length;
         let importsResolved = 0;
         let extendsResolved = 0;
         let implementsResolved = 0;
+        let callsResolved = 0;
         const unresolvedImports = [];
         const unresolvedExtends = [];
         const unresolvedImplements = [];
+        const unresolvedCalls = [];
         for (const deferred of this.deferredEdges) {
+            // Special handling for CALLS edges - uses resolveCallTarget for proper resolution
+            if (deferred.edgeType === CoreEdgeType.CALLS) {
+                const targetNode = this.resolveCallTarget(deferred);
+                if (targetNode) {
+                    const edge = this.createCallsEdge(deferred.sourceNodeId, targetNode.id, deferred.callContext);
+                    resolvedEdges.push(edge);
+                    this.addEdge(edge);
+                    callsResolved++;
+                }
+                else {
+                    const callDesc = deferred.callContext?.receiverType
+                        ? `${deferred.callContext.receiverType}.${deferred.targetName}`
+                        : deferred.targetName;
+                    unresolvedCalls.push(callDesc);
+                }
+                continue;
+            }
             // Pass filePath for precise matching (especially important for EXTENDS/IMPLEMENTS)
             const targetNode = this.findNodeByNameAndType(deferred.targetName, deferred.targetType, deferred.targetFilePath);
             if (targetNode) {
                 const edge = this.createCoreEdge(deferred.edgeType, deferred.sourceNodeId, targetNode.id);
+                resolvedEdges.push(edge);
                 this.addEdge(edge);
-                // Track resolution by type
                 if (deferred.edgeType === CoreEdgeType.IMPORTS) {
                     importsResolved++;
                 }
@@ -495,7 +1176,6 @@ export class TypeScriptParser {
                 }
             }
             else {
-                // Track unresolved by type
                 if (deferred.edgeType === CoreEdgeType.IMPORTS) {
                     unresolvedImports.push(deferred.targetName);
                 }
@@ -507,208 +1187,40 @@ export class TypeScriptParser {
                 }
             }
         }
-        // Log import resolution stats
-        if (importsCount > 0) {
-            await debugLog('Import edge resolution', {
-                totalImports: importsCount,
+        // Log edge resolution stats
+        await debugLog('Edge resolution', {
+            totalDeferredEdges: this.deferredEdges.length,
+            totalNodesAvailable: this.parsedNodes.size + this.existingNodes.size,
+            imports: {
+                queued: importsCount,
                 resolved: importsResolved,
-                unresolvedCount: unresolvedImports.length,
-                unresolvedSample: unresolvedImports.slice(0, 10),
-            });
-        }
-        // Log inheritance (EXTENDS/IMPLEMENTS) resolution stats
-        if (extendsCount > 0 || implementsCount > 0) {
-            await debugLog('Inheritance edge resolution', {
-                extendsQueued: extendsCount,
-                extendsResolved,
-                extendsUnresolved: unresolvedExtends.length,
-                unresolvedExtendsSample: unresolvedExtends.slice(0, 10),
-                implementsQueued: implementsCount,
-                implementsResolved,
-                implementsUnresolved: unresolvedImplements.length,
-                unresolvedImplementsSample: unresolvedImplements.slice(0, 10),
-            });
-        }
+                unresolved: unresolvedImports.length,
+                sample: unresolvedImports.slice(0, 10),
+            },
+            extends: {
+                queued: extendsCount,
+                resolved: extendsResolved,
+                unresolved: unresolvedExtends.length,
+                sample: unresolvedExtends.slice(0, 10),
+            },
+            implements: {
+                queued: implementsCount,
+                resolved: implementsResolved,
+                unresolved: unresolvedImplements.length,
+                sample: unresolvedImplements.slice(0, 10),
+            },
+            calls: {
+                queued: callsCount,
+                resolved: callsResolved,
+                unresolved: unresolvedCalls.length,
+                sample: unresolvedCalls.slice(0, 10),
+            },
+        });
         this.deferredEdges = [];
-    }
-    async parseCoreTypeScript(sourceFile) {
-        try {
-            // Create source file node
-            const sourceFileNode = this.createCoreNode(sourceFile, CoreNodeType.SOURCE_FILE);
-            this.addNode(sourceFileNode);
-            // Parse classes
-            for (const classDecl of sourceFile.getClasses()) {
-                const classNode = this.createCoreNode(classDecl, CoreNodeType.CLASS_DECLARATION, {}, sourceFileNode.id);
-                this.addNode(classNode);
-                // File contains class relationship
-                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, classNode.id);
-                this.addEdge(containsEdge);
-                // Parse class decorators
-                for (const decorator of classDecl.getDecorators()) {
-                    const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR, {}, classNode.id);
-                    this.addNode(decoratorNode);
-                    // Class decorated with decorator relationship
-                    const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, classNode.id, decoratorNode.id);
-                    this.addEdge(decoratedEdge);
-                }
-                // Parse methods
-                for (const method of classDecl.getMethods()) {
-                    const methodNode = this.createCoreNode(method, CoreNodeType.METHOD_DECLARATION, {}, classNode.id);
-                    this.addNode(methodNode);
-                    // Class has method relationship
-                    const hasMethodEdge = this.createCoreEdge(CoreEdgeType.HAS_MEMBER, classNode.id, methodNode.id);
-                    this.addEdge(hasMethodEdge);
-                    // Parse method decorators
-                    for (const decorator of method.getDecorators()) {
-                        const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR, {}, methodNode.id);
-                        this.addNode(decoratorNode);
-                        // Method decorated with decorator relationship
-                        const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, methodNode.id, decoratorNode.id);
-                        this.addEdge(decoratedEdge);
-                    }
-                    // Parse method parameters
-                    for (const param of method.getParameters()) {
-                        const paramNode = this.createCoreNode(param, CoreNodeType.PARAMETER_DECLARATION, {}, methodNode.id);
-                        this.addNode(paramNode);
-                        // Method has parameter relationship
-                        const hasParamEdge = this.createCoreEdge(CoreEdgeType.HAS_PARAMETER, methodNode.id, paramNode.id);
-                        this.addEdge(hasParamEdge);
-                        // Parse parameter decorators
-                        for (const decorator of param.getDecorators()) {
-                            const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR, {}, paramNode.id);
-                            this.addNode(decoratorNode);
-                            // Parameter decorated with decorator relationship
-                            const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, paramNode.id, decoratorNode.id);
-                            this.addEdge(decoratedEdge);
-                        }
-                    }
-                }
-                // Parse properties
-                for (const property of classDecl.getProperties()) {
-                    const propertyNode = this.createCoreNode(property, CoreNodeType.PROPERTY_DECLARATION, {}, classNode.id);
-                    this.addNode(propertyNode);
-                    // Class has property relationship
-                    const hasPropertyEdge = this.createCoreEdge(CoreEdgeType.HAS_MEMBER, classNode.id, propertyNode.id);
-                    this.addEdge(hasPropertyEdge);
-                    // Parse property decorators
-                    for (const decorator of property.getDecorators()) {
-                        const decoratorNode = this.createCoreNode(decorator, CoreNodeType.DECORATOR, {}, propertyNode.id);
-                        this.addNode(decoratorNode);
-                        // Property decorated with decorator relationship
-                        const decoratedEdge = this.createCoreEdge(CoreEdgeType.DECORATED_WITH, propertyNode.id, decoratorNode.id);
-                        this.addEdge(decoratedEdge);
-                    }
-                }
-            }
-            // Parse interfaces
-            for (const interfaceDecl of sourceFile.getInterfaces()) {
-                const interfaceNode = this.createCoreNode(interfaceDecl, CoreNodeType.INTERFACE_DECLARATION, {}, sourceFileNode.id);
-                this.addNode(interfaceNode);
-                // File contains interface relationship
-                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, interfaceNode.id);
-                this.addEdge(containsEdge);
-            }
-            // Parse functions
-            for (const funcDecl of sourceFile.getFunctions()) {
-                const functionNode = this.createCoreNode(funcDecl, CoreNodeType.FUNCTION_DECLARATION, {}, sourceFileNode.id);
-                this.addNode(functionNode);
-                // File contains function relationship
-                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, functionNode.id);
-                this.addEdge(containsEdge);
-                // Parse function parameters
-                for (const param of funcDecl.getParameters()) {
-                    const paramNode = this.createCoreNode(param, CoreNodeType.PARAMETER_DECLARATION, {}, functionNode.id);
-                    this.addNode(paramNode);
-                    // Function has parameter relationship
-                    const hasParamEdge = this.createCoreEdge(CoreEdgeType.HAS_PARAMETER, functionNode.id, paramNode.id);
-                    this.addEdge(hasParamEdge);
-                }
-            }
-            // Parse imports
-            for (const importDecl of sourceFile.getImportDeclarations()) {
-                const importNode = this.createCoreNode(importDecl, CoreNodeType.IMPORT_DECLARATION, {}, sourceFileNode.id);
-                this.addNode(importNode);
-                // File contains import relationship
-                const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, importNode.id);
-                this.addEdge(containsEdge);
-                // Try to resolve import to create SourceFile -> SourceFile IMPORTS edge
-                try {
-                    const targetSourceFile = importDecl.getModuleSpecifierSourceFile();
-                    if (targetSourceFile) {
-                        const targetFilePath = targetSourceFile.getFilePath();
-                        // Queue deferred edge - will be resolved after all files are parsed
-                        this.deferredEdges.push({
-                            edgeType: CoreEdgeType.IMPORTS,
-                            sourceNodeId: sourceFileNode.id,
-                            targetName: targetFilePath, // Use file path as "name" for SourceFiles
-                            targetType: CoreNodeType.SOURCE_FILE,
-                        });
-                    }
-                }
-                catch {
-                    // Module resolution failed - external dependency, skip
-                }
-            }
-            // Parse variable declarations if framework schema specifies this file should have them parsed
-            if (this.shouldParseVariables(sourceFile.getFilePath())) {
-                for (const varStatement of sourceFile.getVariableStatements()) {
-                    for (const varDecl of varStatement.getDeclarations()) {
-                        const variableNode = this.createCoreNode(varDecl, CoreNodeType.VARIABLE_DECLARATION, {}, sourceFileNode.id);
-                        this.addNode(variableNode);
-                        // File contains variable relationship
-                        const containsEdge = this.createCoreEdge(CoreEdgeType.CONTAINS, sourceFileNode.id, variableNode.id);
-                        this.addEdge(containsEdge);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Error parsing file ${sourceFile.getFilePath()}:`, error);
-        }
-    }
-    createCoreNode(astNode, coreType, baseProperties = {}, parentId) {
-        const name = this.extractNodeName(astNode, coreType);
-        const filePath = astNode.getSourceFile().getFilePath();
-        const nodeId = generateDeterministicId(this.projectId, coreType, filePath, name, parentId);
-        // Extract base properties using schema
-        const properties = {
-            id: nodeId,
-            projectId: this.projectId,
-            name,
-            coreType,
-            filePath,
-            startLine: astNode.getStartLineNumber(),
-            endLine: astNode.getEndLineNumber(),
-            sourceCode: astNode.getText(),
-            createdAt: new Date().toISOString(),
-            ...baseProperties,
-        };
-        // Extract schema-defined properties
-        const coreNodeDef = this.coreSchema.nodeTypes[coreType];
-        if (coreNodeDef) {
-            for (const propDef of coreNodeDef.properties) {
-                try {
-                    const value = this.extractProperty(astNode, propDef);
-                    if (value !== undefined && propDef.name !== 'context') {
-                        properties[propDef.name] = value;
-                    }
-                }
-                catch (error) {
-                    console.warn(`Failed to extract core property ${propDef.name}:`, error);
-                }
-            }
-        }
-        return {
-            id: nodeId,
-            coreType,
-            labels: [...(coreNodeDef?.neo4j.labels || [])],
-            properties,
-            sourceNode: astNode,
-            skipEmbedding: coreNodeDef?.neo4j.skipEmbedding ?? false,
-        };
+        return resolvedEdges.map(toNeo4jEdge);
     }
     async applyContextExtractors() {
-        console.log('🔧 Applying context extractors...');
+        debugLog('Applying context extractors');
         // Apply global context extractors from framework schemas
         for (const frameworkSchema of this.frameworkSchemas) {
             for (const extractor of frameworkSchema.contextExtractors) {
@@ -736,37 +1248,11 @@ export class TypeScriptParser {
             }
         }
     }
-    createCoreEdge(relationshipType, sourceNodeId, targetNodeId) {
-        // Get the weight from the core schema
-        const coreEdgeSchema = CORE_TYPESCRIPT_SCHEMA.edgeTypes[relationshipType];
-        const relationshipWeight = coreEdgeSchema?.relationshipWeight ?? 0.5;
-        // Generate deterministic edge ID based on type + source + target
-        const edgeIdentity = `${relationshipType}::${sourceNodeId}::${targetNodeId}`;
-        const edgeHash = crypto.createHash('sha256').update(edgeIdentity).digest('hex').substring(0, 16);
-        const edgeId = `${relationshipType}:${edgeHash}`;
-        return {
-            id: edgeId,
-            relationshipType,
-            sourceNodeId,
-            targetNodeId,
-            properties: {
-                coreType: relationshipType,
-                projectId: this.projectId,
-                source: 'ast',
-                confidence: 1.0,
-                relationshipWeight,
-                filePath: '',
-                createdAt: new Date().toISOString(),
-            },
-        };
-    }
     async applyFrameworkEnhancements() {
-        console.log('🎯 Starting framework enhancements...');
+        await debugLog('Applying framework enhancements', { schemas: this.frameworkSchemas.map((s) => s.name) });
         for (const frameworkSchema of this.frameworkSchemas) {
-            console.log(`📦 Applying framework schema: ${frameworkSchema.name}`);
             await this.applyFrameworkSchema(frameworkSchema);
         }
-        console.log('✅ Framework enhancements complete');
     }
     async applyFrameworkSchema(schema) {
         // Sort enhancements by priority (highest first)
@@ -798,7 +1284,11 @@ export class TypeScriptParser {
                         }
                     case 'function':
                         if (typeof pattern.pattern === 'function') {
-                            return pattern.pattern(node);
+                            // Pass the AST sourceNode to pattern functions, not the ParsedNode wrapper
+                            const astNode = node.sourceNode;
+                            if (!astNode)
+                                return false;
+                            return pattern.pattern(astNode);
                         }
                         return false;
                     case 'classname':
@@ -867,7 +1357,7 @@ export class TypeScriptParser {
         }
     }
     async applyEdgeEnhancements() {
-        console.log('🔗 Applying edge enhancements...');
+        await debugLog('Applying edge enhancements');
         for (const frameworkSchema of this.frameworkSchemas) {
             for (const edgeEnhancement of Object.values(frameworkSchema.edgeEnhancements)) {
                 await this.applyEdgeEnhancement(edgeEnhancement);
@@ -876,13 +1366,12 @@ export class TypeScriptParser {
     }
     async applyEdgeEnhancement(edgeEnhancement) {
         try {
-            // Combine parsed nodes and existing nodes for target matching
-            // Sources must be parsed (have AST), targets can be either
+            // Combine parsed nodes and existing nodes for edge matching
+            // Detection patterns should use pre-extracted context, not raw AST
             const allTargetNodes = new Map([...this.parsedNodes, ...this.existingNodes]);
             for (const [sourceId, sourceNode] of this.parsedNodes) {
-                // Skip if source doesn't have AST (shouldn't happen for parsedNodes, but be safe)
-                if (!sourceNode.sourceNode)
-                    continue;
+                // Note: sourceNode.sourceNode may be undefined after AST cleanup
+                // Detection patterns should use pre-extracted context from node.properties.context
                 for (const [targetId, targetNode] of allTargetNodes) {
                     if (sourceId === targetId)
                         continue;
@@ -902,165 +1391,110 @@ export class TypeScriptParser {
             console.error(`Error applying edge enhancement ${edgeEnhancement.name}:`, error);
         }
     }
-    createFrameworkEdge(semanticType, relationshipType, sourceNodeId, targetNodeId, context = {}, relationshipWeight = 0.5) {
-        const { id, properties } = createFrameworkEdgeData({
-            semanticType,
-            sourceNodeId,
-            targetNodeId,
-            projectId: this.projectId,
-            context,
-            relationshipWeight,
-        });
-        return {
-            id,
-            relationshipType,
-            sourceNodeId,
-            targetNodeId,
-            properties,
-        };
+    /**
+     * Apply edge enhancements on all accumulated nodes.
+     * Call this after all chunks have been parsed for streaming mode.
+     * This allows context-dependent edges (like INTERNAL_API_CALL) to be detected
+     * after all nodes and their context have been collected.
+     * @returns New edges created by edge enhancements
+     */
+    async applyEdgeEnhancementsManually() {
+        const edgeCountBefore = this.parsedEdges.size;
+        await this.applyEdgeEnhancements();
+        const newEdgeCount = this.parsedEdges.size - edgeCountBefore;
+        await debugLog('Edge enhancements applied', { nodeCount: this.parsedNodes.size, newEdges: newEdgeCount });
+        // Return only the new edges (those created by edge enhancements)
+        const allEdges = Array.from(this.parsedEdges.values()).map(toNeo4jEdge);
+        return allEdges.slice(edgeCountBefore);
     }
-    extractProperty(astNode, propDef) {
-        const { method, source, defaultValue } = propDef.extraction;
-        try {
-            switch (method) {
-                case 'ast':
-                    if (typeof source === 'string') {
-                        const fn = astNode[source];
-                        return typeof fn === 'function' ? fn.call(astNode) : defaultValue;
-                    }
-                    return defaultValue;
-                case 'function':
-                    if (typeof source === 'function') {
-                        return source(astNode);
-                    }
-                    return defaultValue;
-                case 'static':
-                    return defaultValue;
-                case 'context':
-                    // Context properties are handled by context extractors
-                    return undefined;
-                default:
-                    return defaultValue;
+    addNode(node) {
+        this.parsedNodes.set(node.id, node);
+        this.indexNodeForCallsResolution(node);
+    }
+    /**
+     * Build lookup indexes for efficient CALLS edge resolution.
+     * Called when adding nodes during parsing or from external sources.
+     */
+    indexNodeForCallsResolution(node) {
+        if (node.coreType === CoreNodeType.METHOD_DECLARATION) {
+            const className = this.getClassNameForNode(node);
+            if (className) {
+                if (!this.methodsByClass.has(className)) {
+                    this.methodsByClass.set(className, new Map());
+                }
+                this.methodsByClass.get(className).set(node.properties.name, node);
             }
         }
-        catch (error) {
-            console.warn(`Failed to extract property ${propDef.name}:`, error);
-            return defaultValue;
+        else if (node.coreType === CoreNodeType.FUNCTION_DECLARATION) {
+            this.functionsByName.set(node.properties.name, node);
         }
-    }
-    extractNodeName(astNode, coreType) {
-        try {
-            switch (coreType) {
-                case CoreNodeType.SOURCE_FILE:
-                    if (Node.isSourceFile(astNode)) {
-                        return astNode.getBaseName();
-                    }
-                    break;
-                case CoreNodeType.CLASS_DECLARATION:
-                    if (Node.isClassDeclaration(astNode)) {
-                        return astNode.getName() ?? 'AnonymousClass';
-                    }
-                    break;
-                case CoreNodeType.METHOD_DECLARATION:
-                    if (Node.isMethodDeclaration(astNode)) {
-                        return astNode.getName();
-                    }
-                    break;
-                case CoreNodeType.FUNCTION_DECLARATION:
-                    if (Node.isFunctionDeclaration(astNode)) {
-                        return astNode.getName() ?? 'AnonymousFunction';
-                    }
-                    break;
-                case CoreNodeType.INTERFACE_DECLARATION:
-                    if (Node.isInterfaceDeclaration(astNode)) {
-                        return astNode.getName();
-                    }
-                    break;
-                case CoreNodeType.PROPERTY_DECLARATION:
-                    if (Node.isPropertyDeclaration(astNode)) {
-                        return astNode.getName();
-                    }
-                    break;
-                case CoreNodeType.PARAMETER_DECLARATION:
-                    if (Node.isParameterDeclaration(astNode)) {
-                        return astNode.getName();
-                    }
-                    break;
-                case CoreNodeType.IMPORT_DECLARATION:
-                    if (Node.isImportDeclaration(astNode)) {
-                        return astNode.getModuleSpecifierValue();
-                    }
-                    break;
-                case CoreNodeType.DECORATOR:
-                    if (Node.isDecorator(astNode)) {
-                        return astNode.getName();
-                    }
-                    break;
-                default:
-                    return astNode.getKindName();
+        else if (node.coreType === CoreNodeType.CONSTRUCTOR_DECLARATION) {
+            const className = this.getClassNameForNode(node);
+            if (className) {
+                this.constructorsByClass.set(className, node);
             }
         }
-        catch (error) {
-            console.warn(`Error extracting name for ${coreType}:`, error);
-        }
-        return 'Unknown';
     }
-    shouldSkipChildNode(node) {
-        const excludedNodeTypes = this.parseConfig.excludedNodeTypes ?? [];
-        return excludedNodeTypes.includes(node.getKindName());
+    addEdge(edge) {
+        this.parsedEdges.set(edge.id, edge);
     }
     /**
-     * Safely test if a file path matches a pattern (string or regex).
-     * Falls back to literal string matching if the pattern is an invalid regex.
+     * Get the class name for a node.
+     * Uses the parentClassName property tracked during parsing.
      */
-    matchesPattern(filePath, pattern) {
-        // First try literal string match (always safe)
-        if (filePath.includes(pattern)) {
-            return true;
-        }
-        // Then try regex match with error handling
-        try {
-            return new RegExp(pattern).test(filePath);
-        }
-        catch {
-            // Invalid regex pattern - already checked via includes() above
-            return false;
+    getClassNameForNode(node) {
+        // Use the parentClassName that was tracked during parseChildNodes
+        return node.properties.parentClassName;
+    }
+    /**
+     * Find the parent class node for a method/property node.
+     * Uses the parentClassName property tracked during parsing.
+     */
+    findParentClassNode(node) {
+        const parentClassName = node.properties.parentClassName;
+        if (!parentClassName)
+            return undefined;
+        // Find the class node by name and file path
+        for (const [, classNode] of this.parsedNodes) {
+            if (classNode.coreType === CoreNodeType.CLASS_DECLARATION &&
+                classNode.properties.name === parentClassName &&
+                classNode.properties.filePath === node.properties.filePath) {
+                return classNode;
+            }
         }
+        return undefined;
     }
     shouldSkipFile(sourceFile) {
         const filePath = sourceFile.getFilePath();
         const excludedPatterns = this.parseConfig.excludePatterns ?? [];
         for (const pattern of excludedPatterns) {
-            if (this.matchesPattern(filePath, pattern)) {
+            if (matchesPattern(filePath, pattern)) {
                 return true;
             }
         }
         return false;
     }
-    toNeo4jNode(parsedNode) {
-        return {
-            id: parsedNode.id,
-            labels: parsedNode.labels,
-            properties: parsedNode.properties,
-            skipEmbedding: parsedNode.skipEmbedding ?? false,
-        };
-    }
-    toNeo4jEdge(parsedEdge) {
-        return {
-            id: parsedEdge.id,
-            type: parsedEdge.relationshipType,
-            startNodeId: parsedEdge.sourceNodeId,
-            endNodeId: parsedEdge.targetNodeId,
-            properties: parsedEdge.properties,
-        };
-    }
-    addNode(node) {
-        this.parsedNodes.set(node.id, node);
+    shouldSkipChildNode(node) {
+        const excludedNodeTypes = this.parseConfig.excludedNodeTypes ?? [];
+        return excludedNodeTypes.includes(node.getKindName());
     }
-    addEdge(edge) {
-        this.parsedEdges.set(edge.id, edge);
+    /**
+     * Check if variable declarations should be parsed for this file
+     * based on framework schema configurations
+     */
+    shouldParseVariables(filePath) {
+        for (const schema of this.frameworkSchemas) {
+            const parsePatterns = schema.metadata.parseVariablesFrom;
+            if (parsePatterns) {
+                for (const pattern of parsePatterns) {
+                    if (minimatch(filePath, pattern)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
     }
-    // Helper methods for statistics and debugging
     getStats() {
         const nodesByType = {};
         const nodesBySemanticType = {};
@@ -1093,17 +1527,24 @@ export class TypeScriptParser {
         }));
         return { nodes, edges };
     }
-    // ============================================
-    // CHUNK-AWARE PARSING METHODS
-    // For streaming/chunked parsing of large codebases
-    // ============================================
+    /**
+     * Get count of currently parsed nodes and edges.
+     * Useful for progress reporting.
+     */
+    getCurrentCounts() {
+        return {
+            nodes: this.parsedNodes.size,
+            edges: this.parsedEdges.size,
+            deferredEdges: this.deferredEdges.length,
+        };
+    }
     /**
      * Export current chunk results without clearing internal state.
      * Use this when importing chunks incrementally.
      */
     exportChunkResults() {
-        const nodes = Array.from(this.parsedNodes.values()).map(this.toNeo4jNode);
-        const edges = Array.from(this.parsedEdges.values()).map(this.toNeo4jEdge);
+        const nodes = Array.from(this.parsedNodes.values()).map(toNeo4jNode);
+        const edges = Array.from(this.parsedEdges.values()).map(toNeo4jEdge);
         return {
             nodes,
             edges,
@@ -1118,259 +1559,114 @@ export class TypeScriptParser {
         this.parsedNodes.clear();
         this.parsedEdges.clear();
         this.deferredEdges = [];
+        // Clear CALLS edge lookup indexes
+        this.methodsByClass.clear();
+        this.functionsByName.clear();
+        this.constructorsByClass.clear();
+        this.exportedNodeIds.clear();
+        this.exportedEdgeIds.clear();
     }
     /**
-     * Get count of currently parsed nodes and edges.
-     * Useful for progress reporting.
-     */
-    getCurrentCounts() {
-        return {
-            nodes: this.parsedNodes.size,
-            edges: this.parsedEdges.size,
-            deferredEdges: this.deferredEdges.length,
-        };
-    }
-    /**
-     * Set the shared context for this parser.
-     * Use this to share context across multiple parsers (e.g., in WorkspaceParser).
-     * @param context The shared context map to use
-     */
-    setSharedContext(context) {
-        this.sharedContext = context;
-    }
-    /**
-     * Get the shared context from this parser.
-     * Useful for aggregating context across multiple parsers.
-     */
-    getSharedContext() {
-        return this.sharedContext;
-    }
-    /**
-     * Get all parsed nodes (for cross-parser edge resolution).
-     * Returns the internal Map of ParsedNodes.
-     */
-    getParsedNodes() {
-        return this.parsedNodes;
-    }
-    /**
-     * Get the framework schemas used by this parser.
-     * Useful for WorkspaceParser to apply cross-package edge enhancements.
-     */
-    getFrameworkSchemas() {
-        return this.frameworkSchemas;
-    }
-    /**
-     * Defer edge enhancements to a parent parser (e.g., WorkspaceParser).
-     * When true, parseChunk() will skip applyEdgeEnhancements().
-     * The parent is responsible for calling applyEdgeEnhancementsManually() at the end.
-     */
-    setDeferEdgeEnhancements(defer) {
-        this.deferEdgeEnhancements = defer;
-    }
-    /**
-     * Get list of source files in the project.
-     * In lazy mode, uses glob to discover files without loading them into memory.
-     * Useful for determining total work and creating chunks.
+     * Add nodes to the existing nodes map for cross-chunk edge resolution.
+     * These nodes are considered as potential edge targets but won't be exported.
      */
-    async discoverSourceFiles() {
-        if (this.discoveredFiles !== null) {
-            return this.discoveredFiles;
-        }
-        if (this.lazyLoad) {
-            // Use glob to find files without loading them into ts-morph
-            // Include both .ts and .tsx files
-            const pattern = path.join(this.workspacePath, '**/*.{ts,tsx}');
-            const allFiles = await glob(pattern, {
-                ignore: ['**/node_modules/**', '**/*.d.ts'],
-                absolute: true,
-            });
-            // Apply exclude patterns from parseConfig
-            const excludedPatterns = this.parseConfig.excludePatterns ?? [];
-            this.discoveredFiles = allFiles.filter((filePath) => {
-                for (const excludePattern of excludedPatterns) {
-                    if (this.matchesPattern(filePath, excludePattern)) {
-                        return false;
-                    }
-                }
-                return true;
-            });
-            console.log(`🔍 Discovered ${this.discoveredFiles.length} TypeScript files (lazy mode)`);
-            return this.discoveredFiles;
-        }
-        else {
-            // Eager mode - files are already loaded
-            this.discoveredFiles = this.project
-                .getSourceFiles()
-                .filter((sf) => !this.shouldSkipFile(sf))
-                .map((sf) => sf.getFilePath());
-            return this.discoveredFiles;
+    addExistingNodesFromChunk(nodes) {
+        for (const node of nodes) {
+            const parsedNode = {
+                id: node.id,
+                coreType: node.properties.coreType,
+                semanticType: node.properties.semanticType,
+                labels: node.labels,
+                properties: node.properties,
+            };
+            this.existingNodes.set(node.id, parsedNode);
+            this.indexNodeForCallsResolution(parsedNode);
         }
     }
     /**
-     * @deprecated Use discoverSourceFiles() instead for async file discovery
+     * Add nodes to parsedNodes for edge enhancement.
+     * Use this when coordinator needs to run edge enhancements on accumulated chunk results.
+     * Unlike addExistingNodesFromChunk, these nodes ARE used as edge sources.
      */
-    getSourceFilePaths() {
-        if (this.lazyLoad) {
-            throw new Error('getSourceFilePaths() is not supported in lazy mode. Use discoverSourceFiles() instead.');
+    addParsedNodesFromChunk(nodes) {
+        for (const node of nodes) {
+            const parsedNode = {
+                id: node.id,
+                coreType: node.properties.coreType,
+                semanticType: node.properties.semanticType,
+                labels: node.labels,
+                properties: node.properties,
+            };
+            this.parsedNodes.set(node.id, parsedNode);
+            this.indexNodeForCallsResolution(parsedNode);
         }
-        return this.project
-            .getSourceFiles()
-            .filter((sf) => !this.shouldSkipFile(sf))
-            .map((sf) => sf.getFilePath());
     }
     /**
-     * Parse a chunk of files without resolving deferred edges.
-     * Use this for streaming parsing where edges are resolved after all chunks.
-     * In lazy mode, files are added to the project just-in-time and removed after parsing.
-     * @param filePaths Specific file paths to parse
-     * @param skipEdgeResolution If true, deferred edges are not resolved (default: false)
+     * Get serialized shared context for parallel parsing.
+     * Converts Maps to arrays for structured clone compatibility.
      */
-    async parseChunk(filePaths, skipEdgeResolution = false) {
-        // Declare sourceFiles outside try so it's available in finally
-        const sourceFiles = [];
-        try {
-            if (this.lazyLoad) {
-                // Lazy mode: add files to project just-in-time
-                for (const filePath of filePaths) {
-                    try {
-                        // Check if file already exists in project (shouldn't happen in lazy mode)
-                        // Add the file to the project if not already present
-                        const sourceFile = this.project.getSourceFile(filePath) ?? this.project.addSourceFileAtPath(filePath);
-                        sourceFiles.push(sourceFile);
-                    }
-                    catch (error) {
-                        console.warn(`Failed to add source file ${filePath}:`, error);
-                    }
-                }
+    getSerializedSharedContext() {
+        const serialized = [];
+        for (const [key, value] of this.sharedContext) {
+            // Convert nested Maps to arrays
+            if (value instanceof Map) {
+                serialized.push([key, Array.from(value.entries())]);
             }
             else {
-                // Eager mode: files are already loaded
-                const loadedFiles = filePaths
-                    .map((filePath) => this.project.getSourceFile(filePath))
-                    .filter((sf) => sf !== undefined);
-                sourceFiles.push(...loadedFiles);
-            }
-            for (const sourceFile of sourceFiles) {
-                if (this.shouldSkipFile(sourceFile))
-                    continue;
-                await this.parseCoreTypeScriptV2(sourceFile);
-            }
-            // Only resolve edges if not skipping
-            if (!skipEdgeResolution) {
-                await this.resolveDeferredEdges();
-            }
-            await this.applyContextExtractors();
-            if (this.frameworkSchemas.length > 0) {
-                await this.applyFrameworkEnhancements();
-            }
-            // Apply edge enhancements unless deferred to parent (e.g., WorkspaceParser)
-            // When deferred, parent will call applyEdgeEnhancementsManually() at the end
-            // with all accumulated nodes for cross-package edge detection
-            if (!this.deferEdgeEnhancements) {
-                await this.applyEdgeEnhancements();
-            }
-            const neo4jNodes = Array.from(this.parsedNodes.values()).map(this.toNeo4jNode);
-            const neo4jEdges = Array.from(this.parsedEdges.values()).map(this.toNeo4jEdge);
-            return { nodes: neo4jNodes, edges: neo4jEdges };
-        }
-        finally {
-            // Always clean up in lazy mode to prevent memory leaks
-            if (this.lazyLoad) {
-                for (const sourceFile of sourceFiles) {
-                    try {
-                        this.project.removeSourceFile(sourceFile);
-                    }
-                    catch {
-                        // Ignore errors when removing files
-                    }
-                }
+                serialized.push([key, value]);
             }
         }
+        return serialized;
     }
     /**
-     * Resolve deferred edges against both parsed nodes and existing nodes.
-     * Call this after all chunks have been parsed.
-     * @returns Resolved edges
+     * Merge serialized shared context from workers.
+     * Handles Map merging by combining entries.
      */
-    async resolveDeferredEdgesManually() {
-        const resolvedEdges = [];
-        // Count edges by type for logging
-        const extendsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.EXTENDS).length;
-        const implementsCount = this.deferredEdges.filter((e) => e.edgeType === CoreEdgeType.IMPLEMENTS).length;
-        let extendsResolved = 0;
-        let implementsResolved = 0;
-        const unresolvedExtends = [];
-        const unresolvedImplements = [];
-        for (const deferred of this.deferredEdges) {
-            // Pass filePath for precise matching (especially important for EXTENDS/IMPLEMENTS)
-            const targetNode = this.findNodeByNameAndType(deferred.targetName, deferred.targetType, deferred.targetFilePath);
-            if (targetNode) {
-                const edge = this.createCoreEdge(deferred.edgeType, deferred.sourceNodeId, targetNode.id);
-                resolvedEdges.push(edge);
-                this.addEdge(edge);
-                if (deferred.edgeType === CoreEdgeType.EXTENDS) {
-                    extendsResolved++;
-                }
-                else if (deferred.edgeType === CoreEdgeType.IMPLEMENTS) {
-                    implementsResolved++;
+    mergeSerializedSharedContext(serialized) {
+        for (const [key, value] of serialized) {
+            if (Array.isArray(value) && value.length > 0 && Array.isArray(value[0])) {
+                // It's a serialized Map - merge with existing
+                const existingMap = this.sharedContext.get(key);
+                const newMap = existingMap ?? new Map();
+                for (const [k, v] of value) {
+                    newMap.set(k, v);
                 }
+                this.sharedContext.set(key, newMap);
             }
             else {
-                if (deferred.edgeType === CoreEdgeType.EXTENDS) {
-                    unresolvedExtends.push(deferred.targetName);
-                }
-                else if (deferred.edgeType === CoreEdgeType.IMPLEMENTS) {
-                    unresolvedImplements.push(deferred.targetName);
-                }
+                // Simple value - just set it
+                this.sharedContext.set(key, value);
             }
         }
-        // Log inheritance resolution stats
-        if (extendsCount > 0 || implementsCount > 0) {
-            await debugLog('Inheritance edge resolution (manual)', {
-                extendsQueued: extendsCount,
-                extendsResolved,
-                extendsUnresolved: unresolvedExtends.length,
-                unresolvedExtendsSample: unresolvedExtends.slice(0, 10),
-                implementsQueued: implementsCount,
-                implementsResolved,
-                implementsUnresolved: unresolvedImplements.length,
-                unresolvedImplementsSample: unresolvedImplements.slice(0, 10),
-            });
-        }
-        this.deferredEdges = [];
-        return resolvedEdges.map(this.toNeo4jEdge);
     }
     /**
-     * Apply edge enhancements on all accumulated nodes.
-     * Call this after all chunks have been parsed for streaming mode.
-     * This allows context-dependent edges (like INTERNAL_API_CALL) to be detected
-     * after all nodes and their context have been collected.
-     * @returns New edges created by edge enhancements
+     * Get deferred edges for cross-chunk resolution.
+     * Returns serializable format for worker thread transfer.
      */
-    async applyEdgeEnhancementsManually() {
-        const edgeCountBefore = this.parsedEdges.size;
-        console.log(`🔗 Applying edge enhancements on ${this.parsedNodes.size} accumulated nodes...`);
-        await this.applyEdgeEnhancements();
-        const newEdgeCount = this.parsedEdges.size - edgeCountBefore;
-        console.log(`   ✅ Created ${newEdgeCount} edges from edge enhancements`);
-        // Return only the new edges (those created by edge enhancements)
-        const allEdges = Array.from(this.parsedEdges.values()).map(this.toNeo4jEdge);
-        return allEdges.slice(edgeCountBefore);
+    getDeferredEdges() {
+        return this.deferredEdges.map((e) => ({
+            edgeType: e.edgeType,
+            sourceNodeId: e.sourceNodeId,
+            targetName: e.targetName,
+            targetType: e.targetType,
+            targetFilePath: e.targetFilePath,
+            callContext: e.callContext,
+        }));
     }
     /**
-     * Add nodes to the existing nodes map for cross-chunk edge resolution.
-     * These nodes are considered as potential edge targets but won't be exported.
+     * Merge deferred edges from workers for resolution.
+     * Converts back to internal format with CoreEdgeType/CoreNodeType.
      */
-    addExistingNodesFromChunk(nodes) {
-        for (const node of nodes) {
-            const parsedNode = {
-                id: node.id,
-                coreType: node.properties.coreType,
-                semanticType: node.properties.semanticType,
-                labels: node.labels,
-                properties: node.properties,
-            };
-            this.existingNodes.set(node.id, parsedNode);
+    mergeDeferredEdges(edges) {
+        for (const e of edges) {
+            this.deferredEdges.push({
+                edgeType: e.edgeType,
+                sourceNodeId: e.sourceNodeId,
+                targetName: e.targetName,
+                targetType: e.targetType,
+                targetFilePath: e.targetFilePath,
+                callContext: e.callContext,
+            });
         }
     }
 }