@grafema/core 0.1.1-alpha → 0.2.1-beta

package/dist/plugins/enrichment/ExternalCallResolver.js

@@ -0,0 +1,213 @@
+/**
+ * ExternalCallResolver - creates CALLS edges for external package calls (REG-226)
+ *
+ * This enrichment plugin runs AFTER FunctionCallResolver (priority 70 vs 80) and:
+ * 1. Finds CALL nodes without CALLS edges (excluding method calls)
+ * 2. For each, looks for IMPORT with matching local name in same file
+ * 3. If import source is non-relative (external package), creates CALLS edge to EXTERNAL_MODULE
+ * 4. Recognizes JS built-in global functions (no edge needed, just counts them)
+ *
+ * CREATES NODES:
+ * - EXTERNAL_MODULE (for external packages like lodash, @tanstack/react-query)
+ *
+ * CREATES EDGES:
+ * - CALL -> CALLS -> EXTERNAL_MODULE (for imported external functions)
+ *
+ * Architecture:
+ * - Runs after FunctionCallResolver handles relative imports
+ * - Skips method calls (have 'object' attribute)
+ * - Skips already resolved calls (have CALLS edge)
+ * - Creates EXTERNAL_MODULE nodes lazily (only when needed)
+ * - Uses import index for O(1) lookups
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import { JS_GLOBAL_FUNCTIONS } from '../../data/builtins/index.js';
+// === PLUGIN CLASS ===
+export class ExternalCallResolver extends Plugin {
+    get metadata() {
+        return {
+            name: 'ExternalCallResolver',
+            phase: 'ENRICHMENT',
+            priority: 70, // After FunctionCallResolver (80)
+            creates: {
+                nodes: ['EXTERNAL_MODULE'],
+                edges: ['CALLS']
+            },
+            dependencies: ['FunctionCallResolver'] // Requires relative imports to be resolved first
+        };
+    }
+    async execute(context) {
+        const { graph, onProgress } = context;
+        const logger = this.log(context);
+        logger.info('Starting external call resolution');
+        const startTime = Date.now();
+        // Step 1: Build Import Index - Map<file:local, ImportNode>
+        // Only index non-relative imports (external packages)
+        const importIndex = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+            const imp = node;
+            if (!imp.file || !imp.local || !imp.source)
+                continue;
+            // Only index external imports (non-relative)
+            const isRelative = imp.source.startsWith('./') || imp.source.startsWith('../');
+            if (isRelative)
+                continue;
+            const key = `${imp.file}:${imp.local}`;
+            importIndex.set(key, imp);
+        }
+        logger.debug('Indexed external imports', { count: importIndex.size });
+        // Step 2: Collect unresolved CALL nodes (excluding method calls)
+        const callsToProcess = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            const call = node;
+            // Skip method calls (have object attribute)
+            if (call.object)
+                continue;
+            // Skip if already has CALLS edge
+            const existingEdges = await graph.getOutgoingEdges(call.id, ['CALLS']);
+            if (existingEdges.length > 0)
+                continue;
+            callsToProcess.push(call);
+        }
+        logger.info('Found calls to process', { count: callsToProcess.length });
+        // Step 3: Track created EXTERNAL_MODULE nodes to avoid duplicates
+        const createdExternalModules = new Set();
+        // Pre-check existing EXTERNAL_MODULE nodes
+        for await (const node of graph.queryNodes({ nodeType: 'EXTERNAL_MODULE' })) {
+            createdExternalModules.add(node.id);
+        }
+        logger.debug('Existing EXTERNAL_MODULE nodes', { count: createdExternalModules.size });
+        // Step 4: Resolution
+        let nodesCreated = 0;
+        let edgesCreated = 0;
+        let callsProcessed = 0;
+        let externalResolved = 0;
+        let builtinResolved = 0;
+        const unresolvedByReason = {
+            unknown: 0,
+            dynamic: 0
+        };
+        for (const callNode of callsToProcess) {
+            callsProcessed++;
+            // Progress reporting
+            if (onProgress && callsProcessed % 100 === 0) {
+                onProgress({
+                    phase: 'enrichment',
+                    currentPlugin: 'ExternalCallResolver',
+                    message: `Processing calls ${callsProcessed}/${callsToProcess.length}`,
+                    totalFiles: callsToProcess.length,
+                    processedFiles: callsProcessed
+                });
+            }
+            const calledName = callNode.name;
+            const file = callNode.file;
+            if (!calledName || !file) {
+                unresolvedByReason.unknown++;
+                continue;
+            }
+            // Step 4.1: Check if this is a JS builtin
+            if (JS_GLOBAL_FUNCTIONS.has(calledName)) {
+                builtinResolved++;
+                continue; // No edge needed, just count it
+            }
+            // Step 4.2: Check if this is a dynamic call
+            if (callNode.isDynamic) {
+                unresolvedByReason.dynamic++;
+                continue;
+            }
+            // Step 4.3: Find matching import in same file
+            const importKey = `${file}:${calledName}`;
+            const imp = importIndex.get(importKey);
+            if (!imp) {
+                // No import found - this is an unknown call
+                unresolvedByReason.unknown++;
+                continue;
+            }
+            // Step 4.4: Extract package name from import source
+            const packageName = this.extractPackageName(imp.source);
+            if (!packageName) {
+                unresolvedByReason.unknown++;
+                continue;
+            }
+            // Step 4.5: Create or reuse EXTERNAL_MODULE node
+            const externalModuleId = `EXTERNAL_MODULE:${packageName}`;
+            if (!createdExternalModules.has(externalModuleId)) {
+                // Check if node already exists in graph
+                const existingNode = await graph.getNode(externalModuleId);
+                if (!existingNode) {
+                    await graph.addNode({
+                        id: externalModuleId,
+                        type: 'EXTERNAL_MODULE',
+                        name: packageName,
+                        file: '',
+                        line: 0
+                    });
+                    nodesCreated++;
+                }
+                createdExternalModules.add(externalModuleId);
+            }
+            // Step 4.6: Create CALLS edge with metadata
+            // Use 'imported' field for exportedName (the original name in source module)
+            // For default imports, 'imported' is 'default'
+            // For named imports with alias, 'imported' is the original name
+            const exportedName = imp.imported || calledName;
+            await graph.addEdge({
+                type: 'CALLS',
+                src: callNode.id,
+                dst: externalModuleId,
+                metadata: { exportedName }
+            });
+            edgesCreated++;
+            externalResolved++;
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        logger.info('Complete', {
+            nodesCreated,
+            edgesCreated,
+            callsProcessed,
+            externalResolved,
+            builtinResolved,
+            unresolvedByReason,
+            time: `${totalTime}s`
+        });
+        return createSuccessResult({ nodes: nodesCreated, edges: edgesCreated }, {
+            callsProcessed,
+            externalResolved,
+            builtinResolved,
+            unresolvedByReason,
+            timeMs: Date.now() - startTime
+        });
+    }
+    /**
+     * Extract package name from import source.
+     *
+     * Handles:
+     * - Simple packages: 'lodash' -> 'lodash'
+     * - Scoped packages: '@tanstack/react-query' -> '@tanstack/react-query'
+     * - Subpath imports: 'lodash/map' -> 'lodash'
+     * - Scoped subpath: '@scope/pkg/sub' -> '@scope/pkg'
+     *
+     * @param source - Import source string
+     * @returns Package name or null if invalid
+     */
+    extractPackageName(source) {
+        if (!source)
+            return null;
+        // Handle scoped packages (@scope/package)
+        if (source.startsWith('@')) {
+            // @scope/package or @scope/package/subpath
+            const parts = source.split('/');
+            if (parts.length >= 2) {
+                // Return @scope/package (first two parts)
+                return `${parts[0]}/${parts[1]}`;
+            }
+            return null; // Invalid scoped package
+        }
+        // Non-scoped package: lodash or lodash/map
+        const slashIndex = source.indexOf('/');
+        if (slashIndex === -1) {
+            return source; // Simple package name
+        }
+        return source.substring(0, slashIndex); // Package name before subpath
+    }
+}

package/dist/plugins/enrichment/FunctionCallResolver.d.ts

@@ -0,0 +1,58 @@
+/**
+ * FunctionCallResolver - creates CALLS edges for imported function calls
+ *
+ * This enrichment plugin runs AFTER ImportExportLinker (priority 80 vs 90) and:
+ * 1. Finds CALL_SITE nodes without CALLS edges (excluding method calls)
+ * 2. For each, looks for IMPORT with matching local name in same file
+ * 3. Follows IMPORTS_FROM -> EXPORT -> FUNCTION chain
+ * 4. Creates CALLS edge to target FUNCTION
+ *
+ * CREATES EDGES:
+ * - CALL_SITE -> CALLS -> FUNCTION (for imported functions)
+ */
+import { Plugin } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+export declare class FunctionCallResolver extends Plugin {
+    get metadata(): PluginMetadata;
+    execute(context: PluginContext): Promise<PluginResult>;
+    /**
+     * Build a key string for export index lookup.
+     *
+     * @param exp - Export node to build key for
+     * @returns Key in format "default" or "named:name"
+     */
+    private buildExportKey;
+    /**
+     * Extract package name from import source.
+     * Handles: 'lodash', '@tanstack/react-query', 'lodash/map', '@scope/pkg/sub'
+     */
+    private extractPackageName;
+    /**
+     * Resolve module specifier to actual file path using extension fallbacks.
+     * Pattern reused from ImportExportLinker (lines 101-122).
+     *
+     * @param currentDir - Directory of the file containing the import/re-export
+     * @param specifier - The module specifier (e.g., "./utils", "../lib/helpers")
+     * @param fileIndex - Set or Map of known file paths for existence checking
+     * @returns Resolved file path or null if not found
+     */
+    private resolveModulePath;
+    /**
+     * Follow re-export chain to find the final EXPORT node (without source field).
+     *
+     * Algorithm:
+     * 1. If current export has no source -> return it (base case)
+     * 2. Resolve source path to file
+     * 3. Find matching export in that file
+     * 4. Recurse (with cycle detection)
+     *
+     * @param exportNode - Starting export node (may be re-export)
+     * @param exportIndex - Pre-built export index for O(1) lookups
+     * @param knownFiles - Set of known file paths
+     * @param visited - Set of visited export IDs for cycle detection
+     * @param maxDepth - Maximum chain depth (safety limit)
+     * @returns Final export node (without source), external module result, or null if chain broken/circular
+     */
+    private resolveExportChain;
+}
+//# sourceMappingURL=FunctionCallResolver.d.ts.map

package/dist/plugins/enrichment/FunctionCallResolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FunctionCallResolver.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/FunctionCallResolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,MAAM,EAAuB,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAyChF,qBAAa,oBAAqB,SAAQ,MAAM;IAC9C,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAgP5D;;;;;OAKG;IACH,OAAO,CAAC,cAAc;IAOtB;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;;;;;;;OAQG;IACH,OAAO,CAAC,iBAAiB;IAkBzB;;;;;;;;;;;;;;;OAeG;IACH,OAAO,CAAC,kBAAkB;CAkE3B"}

package/dist/plugins/enrichment/FunctionCallResolver.js

@@ -0,0 +1,340 @@
+/**
+ * FunctionCallResolver - creates CALLS edges for imported function calls
+ *
+ * This enrichment plugin runs AFTER ImportExportLinker (priority 80 vs 90) and:
+ * 1. Finds CALL_SITE nodes without CALLS edges (excluding method calls)
+ * 2. For each, looks for IMPORT with matching local name in same file
+ * 3. Follows IMPORTS_FROM -> EXPORT -> FUNCTION chain
+ * 4. Creates CALLS edge to target FUNCTION
+ *
+ * CREATES EDGES:
+ * - CALL_SITE -> CALLS -> FUNCTION (for imported functions)
+ */
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import { dirname, resolve } from 'path';
+import { StrictModeError } from '../../errors/GrafemaError.js';
+// === PLUGIN CLASS ===
+export class FunctionCallResolver extends Plugin {
+    get metadata() {
+        return {
+            name: 'FunctionCallResolver',
+            phase: 'ENRICHMENT',
+            priority: 80, // After ImportExportLinker (90)
+            creates: {
+                nodes: ['EXTERNAL_MODULE'],
+                edges: ['CALLS']
+            },
+            dependencies: ['ImportExportLinker'] // Requires IMPORTS_FROM edges
+        };
+    }
+    async execute(context) {
+        const { graph } = context;
+        const logger = this.log(context);
+        logger.info('Starting function call resolution');
+        const startTime = Date.now();
+        // Step 1: Build Import Index - Map<file:local, ImportNode>
+        const importIndex = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'IMPORT' })) {
+            const imp = node;
+            if (!imp.file || !imp.local)
+                continue;
+            // Skip external imports (non-relative)
+            const isRelative = imp.source && (imp.source.startsWith('./') || imp.source.startsWith('../'));
+            if (!isRelative)
+                continue;
+            const key = `${imp.file}:${imp.local}`;
+            importIndex.set(key, imp);
+        }
+        logger.debug('Indexed imports', { count: importIndex.size });
+        // Step 2: Build Function Index - Map<file, Map<name, FunctionNode>>
+        const functionIndex = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'FUNCTION' })) {
+            const func = node;
+            if (!func.file || !func.name)
+                continue;
+            if (!functionIndex.has(func.file)) {
+                functionIndex.set(func.file, new Map());
+            }
+            functionIndex.get(func.file).set(func.name, func);
+        }
+        logger.debug('Indexed functions', { files: functionIndex.size });
+        // Step 2.5: Build Export Index - Map<file, Map<exportKey, ExportNode>>
+        // This enables O(1) lookup when following re-export chains
+        const exportIndex = new Map();
+        for await (const node of graph.queryNodes({ nodeType: 'EXPORT' })) {
+            const exp = node;
+            if (!exp.file)
+                continue;
+            if (!exportIndex.has(exp.file)) {
+                exportIndex.set(exp.file, new Map());
+            }
+            const fileExports = exportIndex.get(exp.file);
+            fileExports.set(this.buildExportKey(exp), exp);
+        }
+        logger.debug('Indexed exports', { files: exportIndex.size });
+        // Step 2.6: Build set of known files for path resolution
+        const knownFiles = new Set();
+        for (const file of exportIndex.keys()) {
+            knownFiles.add(file);
+        }
+        for (const file of functionIndex.keys()) {
+            knownFiles.add(file);
+        }
+        logger.debug('Indexed known files', { count: knownFiles.size });
+        // Step 3: Collect unresolved CALL_SITE nodes
+        const callSitesToResolve = [];
+        for await (const node of graph.queryNodes({ nodeType: 'CALL' })) {
+            const call = node;
+            // Skip method calls (have object attribute)
+            if (call.object)
+                continue;
+            // Skip if already has CALLS edge
+            const existingEdges = await graph.getOutgoingEdges(call.id, ['CALLS']);
+            if (existingEdges.length > 0)
+                continue;
+            callSitesToResolve.push(call);
+        }
+        logger.info('Found call sites to resolve', { count: callSitesToResolve.length });
+        // Step 4: Resolution
+        let edgesCreated = 0;
+        const skipped = {
+            alreadyResolved: 0,
+            methodCalls: 0,
+            external: 0,
+            missingImport: 0,
+            missingImportsFrom: 0,
+            reExportsBroken: 0 // Re-export chain broken (missing export, file not found, or circular)
+        };
+        let reExportsResolved = 0; // Counter for successfully resolved re-export chains
+        const errors = [];
+        for (const callSite of callSitesToResolve) {
+            const calledName = callSite.name;
+            const file = callSite.file;
+            if (!calledName || !file)
+                continue;
+            // Step 4.1: Find matching import in same file
+            const importKey = `${file}:${calledName}`;
+            const imp = importIndex.get(importKey);
+            if (!imp) {
+                skipped.missingImport++;
+                continue;
+            }
+            // Step 4.2: Follow IMPORTS_FROM edge to find EXPORT
+            const importsFromEdges = await graph.getOutgoingEdges(imp.id, ['IMPORTS_FROM']);
+            if (importsFromEdges.length === 0) {
+                skipped.missingImportsFrom++;
+                continue;
+            }
+            const exportNodeId = importsFromEdges[0].dst;
+            const exportNode = await graph.getNode(exportNodeId);
+            if (!exportNode) {
+                skipped.missingImportsFrom++;
+                continue;
+            }
+            // Step 4.3: Resolve re-export chain (if applicable)
+            let finalExport = exportNode;
+            if (exportNode.source) {
+                // This is a re-export - follow the chain
+                const resolved = this.resolveExportChain(exportNode, exportIndex, knownFiles);
+                if (!resolved) {
+                    // Chain broken or circular
+                    // Distinguish: if visited set would show cycle, it's circular
+                    // For simplicity, count as broken (can add nuance later)
+                    skipped.reExportsBroken++;
+                    // In strict mode, collect error
+                    if (context.strictMode) {
+                        const error = new StrictModeError(`Cannot resolve re-export chain for: ${calledName}`, 'STRICT_BROKEN_IMPORT', {
+                            filePath: file,
+                            lineNumber: callSite.line,
+                            phase: 'ENRICHMENT',
+                            plugin: 'FunctionCallResolver',
+                            calledFunction: calledName,
+                            importSource: imp.source,
+                        }, `Check if the module "${imp.source}" exists and exports "${calledName}"`);
+                        errors.push(error);
+                    }
+                    continue;
+                }
+                // Check if resolved to external module
+                if ('type' in resolved && resolved.type === 'external') {
+                    // Type narrowing: resolved is ExternalModuleResult
+                    const externalResult = resolved;
+                    // Find or create EXTERNAL_MODULE node and create CALLS edge
+                    const externalModuleId = `EXTERNAL_MODULE:${externalResult.packageName}`;
+                    // Check if node exists
+                    let externalNode = await graph.getNode(externalModuleId);
+                    if (!externalNode) {
+                        // Create EXTERNAL_MODULE node
+                        await graph.addNode({
+                            id: externalModuleId,
+                            type: 'EXTERNAL_MODULE',
+                            name: externalResult.packageName,
+                            file: '',
+                            line: 0
+                        });
+                    }
+                    // Create CALLS edge with metadata
+                    await graph.addEdge({
+                        type: 'CALLS',
+                        src: callSite.id,
+                        dst: externalModuleId,
+                        metadata: { exportedName: externalResult.exportedName }
+                    });
+                    edgesCreated++;
+                    reExportsResolved++;
+                    continue;
+                }
+                // At this point, resolved must be ExportNode (not external)
+                finalExport = resolved;
+                reExportsResolved++;
+            }
+            // Step 4.4: Find target FUNCTION via final export's local name
+            const targetFile = finalExport.file;
+            const targetFunctionName = finalExport.local || finalExport.name;
+            if (!targetFile || !targetFunctionName)
+                continue;
+            const fileFunctions = functionIndex.get(targetFile);
+            if (!fileFunctions)
+                continue;
+            const targetFunction = fileFunctions.get(targetFunctionName);
+            if (!targetFunction)
+                continue;
+            // Step 4.5: Create CALLS edge
+            await graph.addEdge({
+                type: 'CALLS',
+                src: callSite.id,
+                dst: targetFunction.id
+            });
+            edgesCreated++;
+        }
+        const totalTime = ((Date.now() - startTime) / 1000).toFixed(2);
+        logger.info('Complete', {
+            edgesCreated,
+            skipped,
+            time: `${totalTime}s`
+        });
+        return createSuccessResult({ nodes: 0, edges: edgesCreated }, {
+            callSitesProcessed: callSitesToResolve.length,
+            edgesCreated,
+            reExportsResolved,
+            skipped,
+            timeMs: Date.now() - startTime
+        }, errors);
+    }
+    /**
+     * Build a key string for export index lookup.
+     *
+     * @param exp - Export node to build key for
+     * @returns Key in format "default" or "named:name"
+     */
+    buildExportKey(exp) {
+        if (exp.exportType === 'default') {
+            return 'default';
+        }
+        return `named:${exp.name || exp.local || 'anonymous'}`;
+    }
+    /**
+     * Extract package name from import source.
+     * Handles: 'lodash', '@tanstack/react-query', 'lodash/map', '@scope/pkg/sub'
+     */
+    extractPackageName(source) {
+        if (!source)
+            return null;
+        // Handle scoped packages (@scope/package)
+        if (source.startsWith('@')) {
+            const parts = source.split('/');
+            if (parts.length >= 2) {
+                return `${parts[0]}/${parts[1]}`;
+            }
+            return null;
+        }
+        // Non-scoped package: lodash or lodash/map
+        const slashIndex = source.indexOf('/');
+        if (slashIndex === -1) {
+            return source;
+        }
+        return source.substring(0, slashIndex);
+    }
+    /**
+     * Resolve module specifier to actual file path using extension fallbacks.
+     * Pattern reused from ImportExportLinker (lines 101-122).
+     *
+     * @param currentDir - Directory of the file containing the import/re-export
+     * @param specifier - The module specifier (e.g., "./utils", "../lib/helpers")
+     * @param fileIndex - Set or Map of known file paths for existence checking
+     * @returns Resolved file path or null if not found
+     */
+    resolveModulePath(currentDir, specifier, fileIndex) {
+        const basePath = resolve(currentDir, specifier);
+        const extensions = ['', '.js', '.ts', '.jsx', '.tsx', '/index.js', '/index.ts'];
+        for (const ext of extensions) {
+            const testPath = basePath + ext;
+            if (fileIndex.has(testPath)) {
+                return testPath;
+            }
+        }
+        return null;
+    }
+    /**
+     * Follow re-export chain to find the final EXPORT node (without source field).
+     *
+     * Algorithm:
+     * 1. If current export has no source -> return it (base case)
+     * 2. Resolve source path to file
+     * 3. Find matching export in that file
+     * 4. Recurse (with cycle detection)
+     *
+     * @param exportNode - Starting export node (may be re-export)
+     * @param exportIndex - Pre-built export index for O(1) lookups
+     * @param knownFiles - Set of known file paths
+     * @param visited - Set of visited export IDs for cycle detection
+     * @param maxDepth - Maximum chain depth (safety limit)
+     * @returns Final export node (without source), external module result, or null if chain broken/circular
+     */
+    resolveExportChain(exportNode, exportIndex, knownFiles, visited = new Set(), maxDepth = 10) {
+        // Safety: max depth exceeded
+        if (maxDepth <= 0) {
+            return null;
+        }
+        // Cycle detection
+        if (visited.has(exportNode.id)) {
+            return null;
+        }
+        visited.add(exportNode.id);
+        // Base case: not a re-export
+        if (!exportNode.source) {
+            return exportNode;
+        }
+        // Recursive case: follow re-export
+        const currentDir = dirname(exportNode.file);
+        const targetFile = this.resolveModulePath(currentDir, exportNode.source, knownFiles);
+        if (!targetFile) {
+            // Check if this is an external module (non-relative source)
+            const source = exportNode.source;
+            const isExternal = !source.startsWith('./') && !source.startsWith('../');
+            if (isExternal) {
+                const packageName = this.extractPackageName(source);
+                if (packageName) {
+                    return {
+                        type: 'external',
+                        packageName,
+                        exportedName: exportNode.local || exportNode.name || ''
+                    };
+                }
+            }
+            return null; // Source file not found and not external
+        }
+        const targetExports = exportIndex.get(targetFile);
+        if (!targetExports) {
+            return null; // No exports in target file
+        }
+        // Find matching export by name
+        // Re-export: export { foo } from './other' - look for named:foo
+        // Re-export default: export { default } from './other' - look for default
+        const nextExport = targetExports.get(this.buildExportKey(exportNode));
+        if (!nextExport) {
+            return null; // Export not found in target
+        }
+        return this.resolveExportChain(nextExport, exportIndex, knownFiles, visited, maxDepth - 1);
+    }
+}

package/dist/plugins/enrichment/HTTPConnectionEnricher.d.ts

@@ -14,12 +14,25 @@ export declare class HTTPConnectionEnricher extends Plugin {
     get metadata(): PluginMetadata;
     execute(context: PluginContext): Promise<PluginResult>;
     /**
-     * Проверяет совпадают ли пути
-     * Поддерживает параметризованные пути: /api/users/:id матчится с /api/users/123
+     * Normalize URL to canonical form for comparison.
+     * Converts both Express params (:id) and template literals (${...}) to {param}.
+     */
+    private normalizeUrl;
+    /**
+     * Check if URL has any parameter placeholders (after normalization)
+     */
+    private hasParamsNormalized;
+    /**
+     * Check if request URL matches route path.
+     * Supports:
+     * - Exact match
+     * - Express params (:id)
+     * - Template literals (${...})
+     * - Concrete values matching params (/users/123 matches /users/:id)
      */
     private pathsMatch;
     /**
-     * Проверяет есть ли параметры в пути
+     * Check if path has parameters (for edge matchType metadata)
      */
     private hasParams;
     /**

package/dist/plugins/enrichment/HTTPConnectionEnricher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HTTPConnectionEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/HTTPConnectionEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AA8BhF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IA8F5D;;;OAGG;IACH,OAAO,CAAC,UAAU;IAqBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,eAAe;CAaxB"}
+{"version":3,"file":"HTTPConnectionEnricher.d.ts","sourceRoot":"","sources":["../../../src/plugins/enrichment/HTTPConnectionEnricher.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,MAAM,EAA0C,MAAM,cAAc,CAAC;AAC9E,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAgChF,qBAAa,sBAAuB,SAAQ,MAAM;IAChD,IAAI,QAAQ,IAAI,cAAc,CAW7B;IAEK,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;IAoH5D;;;OAGG;IACH,OAAO,CAAC,YAAY;IAMpB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B;;;;;;;OAOG;IACH,OAAO,CAAC,UAAU;IAwBlB;;OAEG;IACH,OAAO,CAAC,SAAS;IAMjB;;OAEG;IACH,OAAO,CAAC,eAAe;CAaxB"}