@grafema/core 0.2.4-beta → 0.2.5-beta

package/src/plugins/enrichment/MountPointResolver.ts

@@ -19,8 +19,7 @@ import { Plugin } from '../Plugin.js';
 import { createSuccessResult, createErrorResult } from '@grafema/types';
 import type { PluginMetadata, PluginContext, PluginResult } from '@grafema/types';
 import type { BaseNodeRecord } from '@grafema/types';
-import { dirname, resolve, join } from 'path';
-import { existsSync } from 'fs';
+import { isRelativeImport, resolveRelativeSpecifier } from '../../utils/moduleResolution.js';
 
 interface MountNode {
   id: string;
@@ -51,7 +50,6 @@ export class MountPointResolver extends Plugin {
     return {
       name: 'MountPointResolver',
       phase: 'ENRICHMENT',
-      priority: 90,  // High priority - one of first enrichment plugins
       creates: {
         nodes: [],  // Updates existing nodes
         edges: []   // Doesn't create edges
@@ -62,32 +60,15 @@ export class MountPointResolver extends Plugin {
 
   /**
    * Resolve relative import source to absolute file path.
-   * Replicates JSModuleIndexer.resolveModulePath() logic.
+   * Uses shared utility from moduleResolution.ts (REG-320).
    */
   private resolveImportSource(importSource: string, containingFile: string): string | null {
     // Only handle relative imports
-    if (!importSource.startsWith('./') && !importSource.startsWith('../')) {
+    if (!isRelativeImport(importSource)) {
       return null;  // External package
     }
 
-    const dir = dirname(containingFile);
-    const basePath = resolve(dir, importSource);
-
-    // Try direct path
-    if (existsSync(basePath)) return basePath;
-
-    // Try extensions
-    for (const ext of ['.js', '.mjs', '.jsx', '.ts', '.tsx']) {
-      if (existsSync(basePath + ext)) return basePath + ext;
-    }
-
-    // Try index files
-    for (const indexFile of ['index.js', 'index.ts', 'index.mjs', 'index.tsx']) {
-      const indexPath = join(basePath, indexFile);
-      if (existsSync(indexPath)) return indexPath;
-    }
-
-    return null;
+    return resolveRelativeSpecifier(importSource, containingFile, { useFilesystem: true });
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
@@ -271,7 +252,8 @@ export class MountPointResolver extends Plugin {
     } catch (error) {
       const logger = this.log(context);
       logger.error('Error in MountPointResolver', { error });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 }

package/src/plugins/enrichment/NodejsBuiltinsResolver.ts

@@ -54,7 +54,6 @@ export class NodejsBuiltinsResolver extends Plugin {
     return {
       name: 'NodejsBuiltinsResolver',
       phase: 'ENRICHMENT',
-      priority: 45, // After ImportExportLinker (90), before/around MethodCallResolver (50)
       creates: {
         nodes: ['EXTERNAL_FUNCTION', 'EXTERNAL_MODULE'],
         edges: ['CALLS', 'IMPORTS_FROM']
@@ -87,7 +86,7 @@ export class NodejsBuiltinsResolver extends Plugin {
     let importsFromEdgesCreated = 0;
 
     for (const [, importInfo] of importIndex) {
-      const { source, file, localName, importNodeId, importType } = importInfo;
+      const { source, file: _file, localName: _localName, importNodeId, importType: _importType } = importInfo;
       const normalizedSource = this.registry.normalizeModule(source);
 
       if (this.registry.isBuiltinModule(normalizedSource)) {

package/src/plugins/enrichment/PrefixEvaluator.ts

@@ -82,7 +82,6 @@ export class PrefixEvaluator extends Plugin {
     return {
       name: 'PrefixEvaluator',
       phase: 'ENRICHMENT',
-      priority: 80,  // After MountPointResolver (90)
       creates: {
         nodes: [],
         edges: []
@@ -147,8 +146,8 @@ export class PrefixEvaluator extends Plugin {
             plugins: ['jsx', 'typescript'] as ParserPlugin[]
           });
         } catch (error) {
-          const err = error as Error;
-          logger.debug('Failed to parse file', { file: module.file, error: err.message });
+          const message = error instanceof Error ? error.message : String(error);
+          logger.debug('Failed to parse file', { file: module.file, error: message });
           continue;
         }
 
@@ -185,7 +184,8 @@ export class PrefixEvaluator extends Plugin {
     } catch (error) {
       const logger = this.log(context);
       logger.error('Error in PrefixEvaluator', { error });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 

package/src/plugins/enrichment/RejectionPropagationEnricher.ts

@@ -0,0 +1,253 @@
+/**
+ * RejectionPropagationEnricher - propagates rejection types through await chains
+ *
+ * REG-311: When function A awaits function B, and B can reject with ErrorX,
+ * then A also can reject with ErrorX (unless the await is inside try/catch).
+ *
+ * USES:
+ * - FUNCTION nodes with async=true
+ * - CALL nodes with isAwaited/isInsideTry metadata
+ * - CALLS edges to find call targets
+ * - REJECTS edges to find function rejection types
+ *
+ * CREATES:
+ * - FUNCTION -> REJECTS -> CLASS (propagated edges with metadata: { rejectionType: 'propagated', propagatedFrom })
+ *
+ * Priority: 70 (after FunctionCallResolver at 80, needs CALLS edges resolved)
+ */
+
+import { Plugin, createSuccessResult } from '../Plugin.js';
+import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
+import type { BaseNodeRecord, EdgeRecord } from '@grafema/types';
+
+interface FunctionNode extends BaseNodeRecord {
+  async?: boolean;
+}
+
+interface CallNode extends BaseNodeRecord {
+  isAwaited?: boolean;
+  isInsideTry?: boolean;
+}
+
+export class RejectionPropagationEnricher extends Plugin {
+  static MAX_ITERATIONS = 10;
+
+  get metadata(): PluginMetadata {
+    return {
+      name: 'RejectionPropagationEnricher',
+      phase: 'ENRICHMENT',
+      creates: {
+        nodes: [],
+        edges: ['REJECTS']
+      },
+      dependencies: ['JSASTAnalyzer'] // Needs FUNCTION, CALL nodes with metadata
+    };
+  }
+
+  async execute(context: PluginContext): Promise<PluginResult> {
+    const { graph, onProgress } = context;
+    const logger = this.log(context);
+
+    logger.info('Starting rejection propagation through await chains');
+
+    let totalEdgesCreated = 0;
+    let iterations = 0;
+
+    // Step 1: Build function index (id -> FunctionNode)
+    const functionIndex = new Map<string, FunctionNode>();
+    const asyncFunctions: FunctionNode[] = [];
+
+    for await (const node of graph.queryNodes({ type: 'FUNCTION' })) {
+      const funcNode = node as FunctionNode;
+      functionIndex.set(node.id, funcNode);
+      if (funcNode.async) {
+        asyncFunctions.push(funcNode);
+      }
+    }
+
+    logger.info('Indexed functions', { total: functionIndex.size, async: asyncFunctions.length });
+
+    if (asyncFunctions.length === 0) {
+      logger.info('No async functions found, skipping propagation');
+      return createSuccessResult({ nodes: 0, edges: 0 }, { reason: 'no_async_functions' });
+    }
+
+    // Step 2: Build REJECTS index (functionId -> Set<errorClassId>)
+    const rejectsByFunction = new Map<string, Set<string>>();
+
+    for (const [funcId] of functionIndex) {
+      const rejectsEdges = await graph.getOutgoingEdges(funcId, ['REJECTS']);
+      if (rejectsEdges.length > 0) {
+        const rejectsSet = new Set<string>();
+        for (const edge of rejectsEdges) {
+          rejectsSet.add(edge.dst);
+        }
+        rejectsByFunction.set(funcId, rejectsSet);
+      }
+    }
+
+    logger.debug('Indexed REJECTS edges', { functionsWithRejects: rejectsByFunction.size });
+
+    // Step 3: Build CALLS index (callNodeId -> targetFunctionIds)
+    const callTargets = new Map<string, string[]>();
+
+    // Step 4: Build call-to-containing-function mapping and CALLS index
+    const callsByFunction = new Map<string, CallNode[]>();
+
+    for await (const node of graph.queryNodes({ type: 'CALL' })) {
+      const callNode = node as CallNode;
+
+      // Build CALLS index for this call node
+      const callsEdges = await graph.getOutgoingEdges(callNode.id, ['CALLS']);
+      if (callsEdges.length > 0) {
+        const targets: string[] = [];
+        for (const edge of callsEdges) {
+          targets.push(edge.dst);
+        }
+        callTargets.set(callNode.id, targets);
+      }
+
+      // Find containing function by walking up CONTAINS/HAS_SCOPE edges
+      const containingFunctionId = await this.findContainingFunction(
+        callNode.id,
+        functionIndex,
+        graph
+      );
+
+      if (containingFunctionId) {
+        if (!callsByFunction.has(containingFunctionId)) {
+          callsByFunction.set(containingFunctionId, []);
+        }
+        callsByFunction.get(containingFunctionId)!.push(callNode);
+      }
+    }
+
+    logger.debug('Mapped calls to functions', { functionsWithCalls: callsByFunction.size, callsWithTargets: callTargets.size });
+
+    // Step 5: Iterate until fixpoint
+    let changed = true;
+
+    while (changed && iterations < RejectionPropagationEnricher.MAX_ITERATIONS) {
+      iterations++;
+      changed = false;
+      let iterationEdges = 0;
+
+      if (onProgress) {
+        onProgress({
+          phase: 'enrichment',
+          currentPlugin: 'RejectionPropagationEnricher',
+          message: `Propagation iteration ${iterations}`,
+          processedFiles: iterations,
+          totalFiles: RejectionPropagationEnricher.MAX_ITERATIONS
+        });
+      }
+
+      for (const asyncFunc of asyncFunctions) {
+        const calls = callsByFunction.get(asyncFunc.id) || [];
+
+        for (const call of calls) {
+          // Only propagate for awaited calls NOT inside try
+          if (!call.isAwaited || call.isInsideTry) {
+            continue;
+          }
+
+          const targets = callTargets.get(call.id) || [];
+
+          for (const targetId of targets) {
+            const targetRejects = rejectsByFunction.get(targetId);
+            if (!targetRejects || targetRejects.size === 0) {
+              continue;
+            }
+
+            // Ensure caller has a rejection set
+            if (!rejectsByFunction.has(asyncFunc.id)) {
+              rejectsByFunction.set(asyncFunc.id, new Set());
+            }
+            const callerRejects = rejectsByFunction.get(asyncFunc.id)!;
+
+            // Propagate each rejection type
+            for (const errorClassId of targetRejects) {
+              if (!callerRejects.has(errorClassId)) {
+                // Use addEdges with skipValidation=true because the dst (CLASS node)
+                // may not exist as a graph node (e.g., built-in Error classes)
+                const graphWithAddEdges = graph as unknown as {
+                  addEdges(edges: EdgeRecord[], skipValidation?: boolean): Promise<void>
+                };
+                await graphWithAddEdges.addEdges([{
+                  type: 'REJECTS',
+                  src: asyncFunc.id,
+                  dst: errorClassId,
+                  metadata: {
+                    rejectionType: 'propagated',
+                    propagatedFrom: targetId
+                  }
+                }], true /* skipValidation */);
+
+                callerRejects.add(errorClassId);
+                iterationEdges++;
+                totalEdgesCreated++;
+                changed = true;
+              }
+            }
+          }
+        }
+      }
+
+      logger.debug('Propagation iteration completed', { iteration: iterations, edgesCreated: iterationEdges });
+    }
+
+    const summary = {
+      iterations,
+      asyncFunctionsProcessed: asyncFunctions.length,
+      edgesCreated: totalEdgesCreated
+    };
+
+    logger.info('Rejection propagation completed', summary);
+
+    return createSuccessResult({ nodes: 0, edges: totalEdgesCreated }, summary);
+  }
+
+  /**
+   * Find the containing FUNCTION node for a given node ID.
+   * Walks up CONTAINS and HAS_SCOPE edges until a FUNCTION is found.
+   */
+  private async findContainingFunction(
+    nodeId: string,
+    functionIndex: Map<string, FunctionNode>,
+    graph: PluginContext['graph']
+  ): Promise<string | null> {
+    const visited = new Set<string>();
+    let currentId = nodeId;
+    const maxDepth = 20;
+    let depth = 0;
+
+    while (depth < maxDepth) {
+      depth++;
+
+      if (visited.has(currentId)) {
+        break; // Cycle detected
+      }
+      visited.add(currentId);
+
+      // Get incoming CONTAINS and HAS_SCOPE edges
+      // SCOPE -> CONTAINS -> CALL
+      // FUNCTION -> HAS_SCOPE -> SCOPE
+      const incomingEdges = await graph.getIncomingEdges(currentId, ['CONTAINS', 'HAS_SCOPE']);
+
+      if (incomingEdges.length === 0) {
+        break; // No more parents
+      }
+
+      const parentId = incomingEdges[0].src;
+
+      // Check if parent is a FUNCTION
+      if (functionIndex.has(parentId)) {
+        return parentId;
+      }
+
+      currentId = parentId;
+    }
+
+    return null;
+  }
+}

package/src/plugins/enrichment/RustFFIEnricher.ts

@@ -29,7 +29,6 @@ export class RustFFIEnricher extends Plugin {
     return {
       name: 'RustFFIEnricher',
       phase: 'ENRICHMENT',
-      priority: 45,  // After MethodCallResolver (50)
       creates: {
         nodes: [],
         edges: ['FFI_CALLS']

package/src/plugins/enrichment/ValueDomainAnalyzer.ts

@@ -108,11 +108,11 @@ export class ValueDomainAnalyzer extends Plugin {
     return {
       name: 'ValueDomainAnalyzer',
       phase: 'ENRICHMENT',
-      priority: 65, // After AliasTracker (60)
       creates: {
         nodes: [],
         edges: ['CALLS', 'FLOWS_INTO']  // Added FLOWS_INTO (modifies existing)
-      }
+      },
+      dependencies: ['AliasTracker']
     };
   }
 
@@ -576,7 +576,7 @@ export class ValueDomainAnalyzer extends Plugin {
    * @param graph - Graph backend with edge operations
    * @returns Statistics about resolution
    */
-  async resolveComputedMutations(graph: Graph, logger: ReturnType<typeof this.log>): Promise<{
+  async resolveComputedMutations(graph: Graph, _logger: ReturnType<typeof this.log>): Promise<{
     resolved: number;
     conditional: number;
     unknownParameter: number;

package/src/plugins/indexing/IncrementalModuleIndexer.ts

@@ -3,18 +3,20 @@
  * Стартует с entry файла, затем анализирует импорты и добавляет новые файлы в очередь
  */
 
-import { readFileSync, existsSync } from 'fs';
-import { join, dirname, resolve, extname, relative } from 'path';
+import { readFileSync } from 'fs';
+import { join, dirname, resolve, relative } from 'path';
 import { createHash } from 'crypto';
-import { parse, ParserPlugin } from '@babel/parser';
+import type { ParserPlugin } from '@babel/parser';
+import { parse } from '@babel/parser';
 import traverseModule from '@babel/traverse';
 import type { NodePath } from '@babel/traverse';
 import type { ImportDeclaration, CallExpression, Identifier } from '@babel/types';
 import { Plugin, createSuccessResult, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 import type { NodeRecord } from '@grafema/types';
+import { resolveModulePath } from '../../utils/moduleResolution.js';
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ 
 const traverse = (traverseModule as any).default || traverseModule;
 
 /**
@@ -41,7 +43,7 @@ export class IncrementalModuleIndexer extends Plugin {
     return {
       name: 'IncrementalModuleIndexer',
       phase: 'INDEXING',
-      priority: 90,
+      dependencies: [],
       creates: {
         nodes: ['MODULE'],
         edges: ['CONTAINS', 'IMPORTS_FROM']
@@ -79,29 +81,12 @@ export class IncrementalModuleIndexer extends Plugin {
   }
 
   /**
-   * Try to resolve file with different extensions
+   * Try to resolve file with different extensions.
+   * Uses shared utility from moduleResolution.ts (REG-320).
+   * Now supports all extensions (.ts, .tsx, .mjs, .jsx) - fixes previous bug.
    */
   private tryResolve(basePath: string): string | null {
-    if (existsSync(basePath)) {
-      if (!extname(basePath)) {
-        // Try as directory with index.js
-        const indexPath = join(basePath, 'index.js');
-        if (existsSync(indexPath)) return indexPath;
-
-        // Try adding .js
-        if (existsSync(basePath + '.js')) return basePath + '.js';
-      }
-      return basePath;
-    }
-
-    // Try with .js extension
-    if (existsSync(basePath + '.js')) return basePath + '.js';
-
-    // Try as directory
-    const indexPath = join(basePath, 'index.js');
-    if (existsSync(indexPath)) return indexPath;
-
-    return null;
+    return resolveModulePath(basePath, { useFilesystem: true });
   }
 
   /**
@@ -150,7 +135,7 @@ export class IncrementalModuleIndexer extends Plugin {
       });
 
       return imports;
-    } catch (err) {
+    } catch {
       // Parse error will be logged by execute() when it needs logger context
       return [];
     }
@@ -186,7 +171,11 @@ export class IncrementalModuleIndexer extends Plugin {
 
         // Create MODULE node with semantic ID
         const fileHash = this.calculateFileHash(file);
-        const relativePath = relative(projectPath, file);
+        const baseRelativePath = relative(projectPath, file);
+        // REG-76: Prefix with rootPrefix for multi-root workspace support
+        const relativePath = context.rootPrefix
+          ? `${context.rootPrefix}/${baseRelativePath}`
+          : baseRelativePath;
         const semanticId = `${relativePath}->global->MODULE->module`;
 
         const moduleNode: NodeRecord = {
@@ -214,7 +203,11 @@ export class IncrementalModuleIndexer extends Plugin {
         totalImportsParsed += imports.length;
         for (const importFile of imports) {
           // Store for later edge creation with semantic ID format
-          const importRelativePath = relative(projectPath, importFile);
+          const importBaseRelativePath = relative(projectPath, importFile);
+          // REG-76: Prefix with rootPrefix for multi-root workspace support
+          const importRelativePath = context.rootPrefix
+            ? `${context.rootPrefix}/${importBaseRelativePath}`
+            : importBaseRelativePath;
           const importSemanticId = `${importRelativePath}->global->MODULE->module`;
           pendingImports.push({
             src: moduleNode.id,
@@ -290,7 +283,8 @@ export class IncrementalModuleIndexer extends Plugin {
 
     } catch (error) {
       logger.error('Indexing failed', { error });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 }

package/src/plugins/indexing/JSModuleIndexer.ts

@@ -11,8 +11,8 @@ import { Plugin, createErrorResult } from '../Plugin.js';
 import type { PluginContext, PluginResult, PluginMetadata } from '../Plugin.js';
 // @ts-expect-error - no type declarations for node-source-walk
 import Walker from 'node-source-walk';
-import { NodeFactory } from '../../core/NodeFactory.js';
 import { LanguageError } from '../../errors/GrafemaError.js';
+import { resolveModulePath as resolveModulePathUtil } from '../../utils/moduleResolution.js';
 
 /**
  * Manifest with service info
@@ -141,7 +141,7 @@ export class JSModuleIndexer extends Plugin {
     return {
       name: 'JSModuleIndexer',
       phase: 'INDEXING',
-      priority: 90,
+      dependencies: [],
       creates: {
         nodes: ['MODULE'],
         edges: ['CONTAINS', 'DEPENDS_ON']
@@ -187,8 +187,9 @@ export class JSModuleIndexer extends Plugin {
         this.cache.set(filePath, []);
         return [];
       }
-      this.cache.set(filePath, new Error((e as Error).message));
-      return new Error((e as Error).message);
+      const message = e instanceof Error ? e.message : String(e);
+      this.cache.set(filePath, new Error(message));
+      return new Error(message);
     }
 
     this.walker.traverse(ast, (node: ASTNode) => {
@@ -237,23 +238,12 @@ export class JSModuleIndexer extends Plugin {
   }
 
   /**
-   * Резолвит путь к модулю (добавляет .js/.ts если нужно)
+   * Resolve module path (adds .js/.ts if needed).
+   * Uses shared utility from moduleResolution.ts (REG-320).
+   * Falls back to original path if not found (preserves original behavior).
    */
   private resolveModulePath(path: string): string {
-    if (existsSync(path)) return path;
-    // Try JavaScript extensions
-    if (existsSync(path + '.js')) return path + '.js';
-    if (existsSync(path + '.mjs')) return path + '.mjs';
-    if (existsSync(path + '.jsx')) return path + '.jsx';
-    // Try TypeScript extensions
-    if (existsSync(path + '.ts')) return path + '.ts';
-    if (existsSync(path + '.tsx')) return path + '.tsx';
-    // Try index files
-    if (existsSync(join(path, 'index.js'))) return join(path, 'index.js');
-    if (existsSync(join(path, 'index.ts'))) return join(path, 'index.ts');
-    if (existsSync(join(path, 'index.mjs'))) return join(path, 'index.mjs');
-    if (existsSync(join(path, 'index.tsx'))) return join(path, 'index.tsx');
-    return path;
+    return resolveModulePathUtil(path, { useFilesystem: true }) ?? path;
   }
 
   async execute(context: PluginContext): Promise<PluginResult> {
@@ -370,7 +360,11 @@ export class JSModuleIndexer extends Plugin {
 
         // Создаём MODULE ноду для текущего файла с semantic ID
         const fileHash = this.calculateFileHash(currentFile);
-        const relativePath = relative(projectPath, currentFile) || basename(currentFile);
+        const baseRelativePath = relative(projectPath, currentFile) || basename(currentFile);
+        // REG-76: Prefix with rootPrefix for multi-root workspace support
+        const relativePath = context.rootPrefix
+          ? `${context.rootPrefix}/${baseRelativePath}`
+          : baseRelativePath;
         const semanticId = `${relativePath}->global->MODULE->module`;
 
         // Construct MODULE node manually to preserve absolute file path for analyzers
@@ -419,7 +413,11 @@ export class JSModuleIndexer extends Plugin {
 
           // Queue DEPENDS_ON edges for later (after all nodes exist)
           // Use semantic ID format for dependency reference
-          const depRelativePath = relative(projectPath, resolvedDep) || basename(resolvedDep);
+          const depBaseRelativePath = relative(projectPath, resolvedDep) || basename(resolvedDep);
+          // REG-76: Prefix with rootPrefix for multi-root workspace support
+          const depRelativePath = context.rootPrefix
+            ? `${context.rootPrefix}/${depBaseRelativePath}`
+            : depBaseRelativePath;
           const depModuleId = `${depRelativePath}->global->MODULE->module`;
           pendingDependsOnEdges.push({
             src: moduleId,
@@ -474,7 +472,8 @@ export class JSModuleIndexer extends Plugin {
 
     } catch (error) {
       logger.error('Indexing failed', { error });
-      return createErrorResult(error as Error);
+      const err = error instanceof Error ? error : new Error(String(error));
+      return createErrorResult(err);
     }
   }
 }

package/src/plugins/indexing/RustModuleIndexer.ts

@@ -29,7 +29,7 @@ export class RustModuleIndexer extends Plugin {
     return {
       name: 'RustModuleIndexer',
       phase: 'INDEXING',
-      priority: 85,  // After JSModuleIndexer (90)
+      dependencies: [],
       creates: {
         nodes: ['RUST_MODULE'],
         edges: ['CONTAINS']
@@ -119,10 +119,14 @@ export class RustModuleIndexer extends Plugin {
       try {
         const content = readFileSync(filePath, 'utf-8');
         const hash = createHash('sha256').update(content).digest('hex');
-        const relativePath = relative(rustRoot, filePath);
-        const moduleName = this.pathToModuleName(relativePath);
+        const baseRelativePath = relative(rustRoot, filePath);
+        const moduleName = this.pathToModuleName(baseRelativePath);
 
-        const nodeId = `RUST_MODULE#${moduleName}#${filePath}`;
+        // REG-76: Prefix with rootPrefix for multi-root workspace support
+        const prefixedPath = context.rootPrefix
+          ? `${context.rootPrefix}/${baseRelativePath}`
+          : baseRelativePath;
+        const nodeId = `RUST_MODULE#${moduleName}#${prefixedPath}`;
 
         await graph.addNode({
           id: nodeId,
@@ -147,7 +151,8 @@ export class RustModuleIndexer extends Plugin {
           });
         }
       } catch (err) {
-        errors.push({ file: filePath, error: (err as Error).message });
+        const message = err instanceof Error ? err.message : String(err);
+        errors.push({ file: filePath, error: message });
       }
     }
 

package/src/plugins/validation/BrokenImportValidator.ts

@@ -77,12 +77,11 @@ export class BrokenImportValidator extends Plugin {
     return {
       name: 'BrokenImportValidator',
       phase: 'VALIDATION',
-      priority: 85, // After enrichment plugins, before general validators
+      dependencies: ['ImportExportLinker', 'FunctionCallResolver'],
       creates: {
         nodes: [],
         edges: []
-      },
-      dependencies: ['ImportExportLinker', 'FunctionCallResolver']
+      }
     };
   }
 

package/src/plugins/validation/CallResolverValidator.ts

@@ -47,12 +47,11 @@ export class CallResolverValidator extends Plugin {
     return {
       name: 'CallResolverValidator',
       phase: 'VALIDATION',
-      priority: 90,
+      dependencies: ['FunctionCallResolver', 'ExternalCallResolver'],
       creates: {
         nodes: [],
         edges: []
-      },
-      dependencies: ['FunctionCallResolver', 'ExternalCallResolver']
+      }
     };
   }
 

package/src/plugins/validation/DataFlowValidator.ts

@@ -50,7 +50,7 @@ export class DataFlowValidator extends Plugin {
     return {
       name: 'DataFlowValidator',
       phase: 'VALIDATION',
-      priority: 100,
+      dependencies: [],
       creates: {
         nodes: [],
         edges: []