pkg-scaffold 3.3.3 → 3.3.5

package/src/ast/ASTAnalyzer.js

@@ -1,175 +1,203 @@
 import ts from 'typescript';
-import fs from 'fs/promises';
-import path from 'path';
-
-/**
- * Enterprise AST Syntax Walker & Feature Extractor
- * Upgraded to use full TypeScript Compiler API (ts.createProgram + TypeChecker)
- * for type-aware cross-file analysis.
- */
-import { OxcAnalyzer } from './OxcAnalyzer.js';
 
 export class ASTAnalyzer {
   constructor(context) {
     this.context = context;
-    this.program = null;
-    this.checker = null;
-    this.oxc = new OxcAnalyzer(context);
+    this.scopeStack = [];
   }
 
   /**
-   * Initializes the TypeScript program for the entire project.
-   * This is crucial for cross-file type resolution.
+   * Returns the TypeScript ScriptKind for a given file path.
+   * Exposed as a public method so WorkerTaskRunner can call it directly.
    */
-  initProgram(filePaths, options = {}) {
-    const defaultOptions = {
-      target: ts.ScriptTarget.Latest,
-      module: ts.ModuleKind.CommonJS,
-      allowJs: true,
-      checkJs: true,
-      esModuleInterop: true,
-      skipLibCheck: true
-    };
-    
-    this.program = ts.createProgram(filePaths, { ...defaultOptions, ...options });
-    this.checker = this.program.getTypeChecker();
+  getScriptKind(filePath) {
+    if (filePath.endsWith('.tsx') || filePath.endsWith('.jsx')) return ts.ScriptKind.TSX;
+    if (filePath.endsWith('.js') || filePath.endsWith('.mjs') || filePath.endsWith('.cjs')) return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+  }
+
+  parseFile(filePath, content, fileNode) {
+    if (this.context.verbose) {
+      console.log(`[AST] Parsing: ${filePath}`);
+    }
+
+    const sourceFile = ts.createSourceFile(
+      filePath,
+      content,
+      ts.ScriptTarget.Latest,
+      true,
+      this.getScriptKind(filePath)
+    );
+
+    this.currentScope = { symbols: new Map(), parent: null };
+    this.scopeStack.push(this.currentScope);
+
+    this.extractTopLevelJSDocSuppreessions(sourceFile, fileNode);
+    this.walkAST(sourceFile, fileNode, sourceFile);
+
+    this.scopeStack.pop(); // Pop the global scope
+    this.currentScope = null;
   }
 
   /**
-   * Processes a file using the initialized program and type checker.
+   * Alias for walkAST used by WorkerTaskRunner (legacy API compatibility).
    */
-  async processFile(filePath, fileNode) {
-    // Fast Path: Use OXC for rapid scanning if type checking is not strictly required for this file
-    if (this.context.fastMode && this.oxc.isAvailable) {
-      const success = await this.oxc.processFile(filePath, fileNode);
-      if (success) return true;
+  walkNode(node, sourceFile, fileNode) {
+    return this.walkAST(node, fileNode, sourceFile);
+  }
+
+  pushScope() {
+    const newScope = { symbols: new Map(), parent: this.currentScope };
+    this.scopeStack.push(newScope);
+    this.currentScope = newScope;
+  }
+
+  popScope() {
+    if (this.scopeStack.length > 1) {
+      this.scopeStack.pop();
+      this.currentScope = this.scopeStack[this.scopeStack.length - 1];
     }
+  }
 
-    if (!this.program) {
-      throw new Error('ASTAnalyzer must be initialized with initProgram() before processing files.');
+  addDeclaredSymbol(name, node, sourceFile) {
+    if (this.currentScope) {
+      const loc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+      this.currentScope.symbols.set(name, { node, line: loc.line + 1, column: loc.character + 1 });
     }
+  }
 
-    const sourceFile = this.program.getSourceFile(filePath);
-    if (!sourceFile) {
-      if (this.context.verbose) {
-        console.error(`[AST Error] Source file not found in program: ${filePath}`);
+  resolveSymbol(name) {
+    for (let i = this.scopeStack.length - 1; i >= 0; i--) {
+      const scope = this.scopeStack[i];
+      if (scope.symbols.has(name)) {
+        return scope.symbols.get(name);
       }
-      return false;
     }
-
-    this.extractTopLevelJSDocSuppreessions(sourceFile, fileNode);
-    this.walkNode(sourceFile, sourceFile, fileNode);
-    
-    return true;
+    return null;
   }
 
-  walkNode(sourceFile, node, fileNode) {
-    if (!node) return;
-
-    // Use type checker to resolve symbols if needed
-    if (ts.isIdentifier(node) && !this.isNodeDeclarationName(node)) {
-      const symbol = this.checker.getSymbolAtLocation(node);
-      if (symbol) {
-        const declarations = symbol.getDeclarations();
-        if (declarations && declarations.length > 0) {
-          const declFile = declarations[0].getSourceFile().fileName;
-          const symbolName = symbol.getName();
-          
-          // Track sub-symbol usage (Property Access)
-          if (ts.isPropertyAccessExpression(node.parent) && node.parent.name === node) {
-             const parentType = this.checker.getTypeAtLocation(node.parent.expression);
-             const parentSymbol = parentType.getSymbol() || parentType.aliasSymbol;
-             if (parentSymbol) {
-               const parentDecl = parentSymbol.getDeclarations()?.[0];
-               if (parentDecl) {
-                 const parentFile = parentDecl.getSourceFile().fileName;
-                 fileNode.memberUsage = fileNode.memberUsage || new Set();
-                 fileNode.memberUsage.add(`${parentFile}:${parentSymbol.getName()}.${symbolName}`);
-               }
-             }
-          }
-
-          if (declFile !== sourceFile.fileName) {
-            fileNode.resolvedReferences = fileNode.resolvedReferences || new Set();
-            fileNode.resolvedReferences.add(`${declFile}:${symbolName}`);
-          }
-        }
-      }
+  walkAST(node, fileNode, sourceFile) {
+    // Handle scope entry for blocks, functions, classes, etc.
+    const isScopeNode = ts.isBlock(node) || ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isModuleDeclaration(node);
+    if (isScopeNode) {
+      this.pushScope();
     }
 
     switch (node.kind) {
-      case ts.SyntaxKind.ImportDeclaration: {
-        this.handleImportDeclaration(node, fileNode);
+      case ts.SyntaxKind.ImportDeclaration:
+        this.handleImportDeclaration(node, fileNode, sourceFile);
         break;
-      }
-      case ts.SyntaxKind.ExportDeclaration: {
+      case ts.SyntaxKind.ExportDeclaration:
         this.handleExportDeclaration(node, fileNode, sourceFile);
         break;
-      }
+      case ts.SyntaxKind.ExportAssignment:
+        fileNode.internalExports.set('default', { type: 'default', start: node.getStart(sourceFile), end: node.getEnd() });
+        break;
+      case ts.SyntaxKind.VariableStatement:
+        this.handleVariableStatement(node, fileNode, sourceFile);
+        break;
       case ts.SyntaxKind.FunctionDeclaration:
       case ts.SyntaxKind.ClassDeclaration:
       case ts.SyntaxKind.InterfaceDeclaration:
       case ts.SyntaxKind.TypeAliasDeclaration:
       case ts.SyntaxKind.EnumDeclaration:
-      case ts.SyntaxKind.ModuleDeclaration: {
+      case ts.SyntaxKind.ModuleDeclaration:
         this.handleNamedDeclaration(node, fileNode, sourceFile);
         break;
-      }
-      case ts.SyntaxKind.VariableStatement: {
-        this.handleVariableStatement(node, fileNode, sourceFile);
+      case ts.SyntaxKind.Identifier:
+        fileNode.instantiatedIdentifiers.add(node.text);
         break;
-      }
-      case ts.SyntaxKind.CallExpression: {
+      case ts.SyntaxKind.StringLiteral:
+      case ts.SyntaxKind.NoSubstitutionTemplateLiteral:
+        fileNode.rawStringReferences.add(node.text);
+        break;
+      case ts.SyntaxKind.PropertyAccessExpression:
+        fileNode.propertyAccessChains.add(node.getText(sourceFile));
+        break;
+      case ts.SyntaxKind.CallExpression:
         this.handleCallExpression(node, fileNode, sourceFile);
         break;
-      }
+      case ts.SyntaxKind.JsxElement:
+      case ts.SyntaxKind.JsxSelfClosingElement:
+        this.handleJsxElement(node, fileNode, sourceFile);
+        break;
+      case ts.SyntaxKind.Decorator:
+        this.handleDecorator(node, fileNode, sourceFile);
+        break;
     }
 
-    ts.forEachChild(node, child => this.walkNode(sourceFile, child, fileNode));
+    ts.forEachChild(node, child => this.walkAST(child, fileNode, sourceFile));
+
+    if (isScopeNode) {
+      this.popScope();
+    }
   }
 
-  handleImportDeclaration(node, fileNode) {
+  handleImportDeclaration(node, fileNode, sourceFile) {
     if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
       const specifier = node.moduleSpecifier.text;
       fileNode.explicitImports.add(specifier);
       
+      // Track external package usage for dependency analysis
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
+
       if (node.importClause) {
+        if (node.importClause.name) {
+          fileNode.importedSymbols.add(`${specifier}:default`);
+        }
         if (node.importClause.namedBindings) {
-          if (ts.isNamedImports(node.importClause.namedBindings)) {
+          if (ts.isNamespaceImport(node.importClause.namedBindings)) {
+            fileNode.importedSymbols.add(`${specifier}:*`);
+          } else if (ts.isNamedImports(node.importClause.namedBindings)) {
             node.importClause.namedBindings.elements.forEach(element => {
-              const importedName = element.name.text;
-              const propertyName = element.propertyName ? element.propertyName.text : importedName;
-              fileNode.importedSymbols.add(`${specifier}:${propertyName}`);
+              const importedName = element.propertyName ? element.propertyName.text : element.name.text;
+              fileNode.importedSymbols.add(`${specifier}:${importedName}`);
             });
-          } else if (ts.isNamespaceImport(node.importClause.namedBindings)) {
-            fileNode.importedSymbols.add(`${specifier}:*`);
           }
         }
-        if (node.importClause.name) {
-          fileNode.importedSymbols.add(`${specifier}:default`);
-        }
       }
     }
   }
 
   handleExportDeclaration(node, fileNode, sourceFile) {
-    // Handle re-exports: export { x } from './y'
-    if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-      const specifier = node.moduleSpecifier.text;
-      if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+    const specifier = node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier) ? node.moduleSpecifier.text : null;
+    
+    if (specifier) {
+      // Re-export from source: export * from './module' or export { x } from './module'
+      fileNode.explicitImports.add(specifier);
+      
+      // Track external package usage from re-exports
+      if (!specifier.startsWith('.') && !specifier.startsWith('/')) {
+        fileNode.externalPackageUsage.add(this._extractPackageName(specifier));
+      }
+
+      if (!node.exportClause) {
+        // export * from './module'
+        fileNode.internalExports.set('*', { type: 're-export-all', source: specifier });
+        fileNode.importedSymbols.add(`${specifier}:*`);
+      } else if (ts.isNamespaceExport(node.exportClause)) {
+        // export * as name from './module'
+        const name = node.exportClause.name.text;
+        fileNode.internalExports.set(name, { type: 're-export-namespace', source: specifier, originalName: '*', start: node.getStart(sourceFile), end: node.getEnd() });
+        fileNode.importedSymbols.add(`${specifier}:*`);
+      } else if (ts.isNamedExports(node.exportClause)) {
+        // export { x, y as z } from './module'
         node.exportClause.elements.forEach(element => {
-          const name = element.name.text;
-          fileNode.internalExports.set(name, { 
-            type: 're-export', 
-            source: specifier,
-            start: node.getStart(sourceFile), 
-            end: node.getEnd() 
-          });
+          const originalName = element.propertyName ? element.propertyName.text : element.name.text;
+          const exportedName = element.name.text;
+          fileNode.internalExports.set(exportedName, { type: 're-export', source: specifier, originalName, start: element.getStart(sourceFile), end: element.getEnd() });
+          fileNode.importedSymbols.add(`${specifier}:${originalName}`);
         });
-      } else {
-        // export * from './y'
-        fileNode.internalExports.set('*', { type: 're-export-all', source: specifier });
       }
+    } else if (node.exportClause && ts.isNamedExports(node.exportClause)) {
+      // Local named exports: export { x, y as z }
+      node.exportClause.elements.forEach(element => {
+        const localName = element.propertyName ? element.propertyName.text : element.name.text;
+        const exportedName = element.name.text;
+        fileNode.internalExports.set(exportedName, { type: 'export', originalName: localName, start: element.getStart(sourceFile), end: element.getEnd() });
+      });
     }
   }
 
@@ -183,35 +211,56 @@ export class ASTAnalyzer {
         start: node.getStart(sourceFile),
         end: node.getEnd()
       };
-
-      fileNode.internalExports.set(name, exportInfo);
       
-      // Phase 4: Drill down into members
+      fileNode.internalExports.set(name, exportInfo);
+
       if (ts.isEnumDeclaration(node)) {
-        exportInfo.members = node.members.map(m => m.name.getText(sourceFile));
+        exportInfo.members = node.members.map(m => ({
+          name: m.name.getText(sourceFile),
+          type: 'enumMember',
+          start: m.getStart(sourceFile),
+          end: m.getEnd()
+        }));
       } else if (ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node)) {
         exportInfo.members = node.members
           .filter(m => m.name)
-          .map(m => m.name.getText(sourceFile));
+          .map(m => ({
+            name: m.name.getText(sourceFile),
+            type: ts.SyntaxKind[m.kind].toLowerCase(),
+            start: m.getStart(sourceFile),
+            end: m.getEnd()
+          }));
       } else if (ts.isModuleDeclaration(node)) {
-        // Handle Namespaces
         const members = [];
         if (node.body && ts.isModuleBlock(node.body)) {
           node.body.statements.forEach(stmt => {
             if (this.hasExportModifier(stmt) && (ts.isVariableStatement(stmt) || ts.isFunctionDeclaration(stmt) || ts.isClassDeclaration(stmt))) {
               if (ts.isVariableStatement(stmt)) {
-                stmt.declarationList.declarations.forEach(d => members.push(d.name.getText(sourceFile)));
+                stmt.declarationList.declarations.forEach(d => members.push({
+                  name: d.name.getText(sourceFile),
+                  type: 'variable',
+                  start: d.getStart(sourceFile),
+                  end: d.getEnd()
+                }));
               } else if (stmt.name) {
-                members.push(stmt.name.getText(sourceFile));
+                members.push({
+                  name: stmt.name.getText(sourceFile),
+                  type: ts.SyntaxKind[stmt.kind].toLowerCase().replace('declaration', ''),
+                  start: stmt.getStart(sourceFile),
+                  end: stmt.getEnd()
+                });
               }
             }
           });
         }
         exportInfo.members = members;
       }
-
+      
       const loc = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
       fileNode.symbolSourceLocations.set(name, { line: loc.line + 1, column: loc.character + 1 });
+      this.addDeclaredSymbol(name, node, sourceFile);
+    } else if (node.name && ts.isIdentifier(node.name)) {
+      this.addDeclaredSymbol(node.name.text, node, sourceFile);
     }
   }
 
@@ -225,32 +274,124 @@ export class ASTAnalyzer {
             start: decl.getStart(sourceFile), 
             end: decl.getEnd() 
           });
+          this.addDeclaredSymbol(name, decl, sourceFile);
+        } else if (decl.name && ts.isObjectBindingPattern(decl.name)) {
+           decl.name.elements.forEach(element => {
+               if(element.name && ts.isIdentifier(element.name)) {
+                   const name = element.name.text;
+                   fileNode.internalExports.set(name, {
+                       type: 'variable',
+                       start: element.getStart(sourceFile),
+                       end: element.getEnd()
+                   });
+                   this.addDeclaredSymbol(name, element, sourceFile);
+               }
+           });
+        } else if (decl.name && ts.isArrayBindingPattern(decl.name)) {
+            decl.name.elements.forEach(element => {
+               if(ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                   const name = element.name.text;
+                   fileNode.internalExports.set(name, {
+                       type: 'variable',
+                       start: element.getStart(sourceFile),
+                       end: element.getEnd()
+                   });
+                   this.addDeclaredSymbol(name, element, sourceFile);
+               }
+           });
+        }
+      });
+    } else {
+      // Non-exported variable declarations also need to be added to scope
+      node.declarationList.declarations.forEach(decl => {
+        if (decl.name && ts.isIdentifier(decl.name)) {
+          this.addDeclaredSymbol(decl.name.text, decl, sourceFile);
+        } else if (decl.name && ts.isObjectBindingPattern(decl.name)) {
+          decl.name.elements.forEach(element => {
+            if (element.name && ts.isIdentifier(element.name)) {
+              this.addDeclaredSymbol(element.name.text, element, sourceFile);
+            }
+          });
+        } else if (decl.name && ts.isArrayBindingPattern(decl.name)) {
+          decl.name.elements.forEach(element => {
+            if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+              this.addDeclaredSymbol(element.name.text, element, sourceFile);
+            }
+          });
         }
       });
     }
   }
 
   handleCallExpression(node, fileNode, sourceFile) {
-    // Trace dynamic imports
+    // Dynamic import(): import('./module').then(...)
     if (node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      const arg = node.arguments[0];
+      if (arg) {
+        if (ts.isStringLiteral(arg)) {
+          fileNode.explicitImports.add(arg.text);
+          fileNode.dynamicImports.add(arg.text);
+          // Track external package usage from dynamic imports
+          if (!arg.text.startsWith('.') && !arg.text.startsWith('/')) {
+            fileNode.externalPackageUsage.add(this._extractPackageName(arg.text));
+          }
+        } else {
+          // Dynamic import with a non-literal expression (e.g., variable or template literal).
+          if (fileNode.calculatedDynamicImports) {
+            fileNode.calculatedDynamicImports.push({ kind: ts.SyntaxKind[arg.kind], start: arg.getStart(sourceFile) });
+          }
+        }
+      }
+    } else if (ts.isIdentifier(node.expression) && node.expression.text === 'require') {
       const arg = node.arguments[0];
       if (arg && ts.isStringLiteral(arg)) {
         fileNode.explicitImports.add(arg.text);
-        fileNode.dynamicImports.add(arg.text);
+        // Track external package usage from require() calls
+        if (!arg.text.startsWith('.') && !arg.text.startsWith('/')) {
+          fileNode.externalPackageUsage.add(this._extractPackageName(arg.text));
+        }
       }
     }
   }
 
-  hasExportModifier(node) {
-    return node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+  handleJsxElement(node, fileNode, sourceFile) {
+    const getElementName = (name) => {
+      if (ts.isIdentifier(name)) return name.text;
+      if (ts.isPropertyAccessExpression(name)) return name.name.text;
+      return 'unknown';
+    };
+
+    const tagName = getElementName(node.openingElement.tagName);
+    fileNode.jsxComponents.add(tagName);
+
+    node.openingElement.attributes.properties.forEach(attr => {
+      if (ts.isJsxAttribute(attr) && ts.isIdentifier(attr.name)) {
+        fileNode.jsxProps.add(`${tagName}:${attr.name.text}`);
+      }
+    });
+  }
+
+  handleDecorator(node, fileNode, sourceFile) {
+    const getDecoratorName = (expr) => {
+      if (ts.isIdentifier(expr)) return expr.text;
+      if (ts.isCallExpression(expr) && ts.isIdentifier(expr.expression)) return expr.expression.text;
+      if (ts.isCallExpression(expr) && ts.isPropertyAccessExpression(expr.expression)) return expr.expression.name.text;
+      return 'unknown';
+    };
+
+    const decoratorName = getDecoratorName(node.expression);
+    fileNode.decorators.add(decoratorName);
+
+    // Optionally, extract decorator arguments
+    if (ts.isCallExpression(node.expression)) {
+      node.expression.arguments.forEach(arg => {
+        // Further analysis of arguments can be done here if needed
+      });
+    }
   }
 
-  isNodeDeclarationName(node) {
-    const parent = node.parent;
-    if (!parent) return false;
-    return (ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || 
-            ts.isClassDeclaration(parent) || ts.isInterfaceDeclaration(parent) || 
-            ts.isEnumDeclaration(parent) || ts.isModuleDeclaration(parent)) && parent.name === node;
+  hasExportModifier(node) {
+    return node.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
   }
 
   extractTopLevelJSDocSuppreessions(sourceFile, fileNode) {
@@ -264,4 +405,18 @@ export class ASTAnalyzer {
       }
     }
   }
+
+  /**
+   * Extracts the root npm package name from an import specifier.
+   * Handles scoped packages (@scope/pkg) and subpath imports (pkg/utils, @scope/pkg/utils).
+   */
+  _extractPackageName(specifier) {
+    if (specifier.startsWith('@')) {
+      // Scoped package: @scope/name or @scope/name/subpath
+      const parts = specifier.split('/');
+      return parts.length >= 2 ? `${parts[0]}/${parts[1]}` : specifier;
+    }
+    // Regular package: name or name/subpath
+    return specifier.split('/')[0];
+  }
 }

package/src/ast/BarrelParser.js

@@ -99,6 +99,18 @@ export class BarrelParser {
           node.declarationList.declarations.forEach(decl => {
             if (ts.isIdentifier(decl.name)) {
               spec.declaredLocalExports.add(decl.name.text);
+            } else if (ts.isObjectBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
+            } else if (ts.isArrayBindingPattern(decl.name)) {
+              decl.name.elements.forEach(element => {
+                if (ts.isBindingElement(element) && element.name && ts.isIdentifier(element.name)) {
+                  spec.declaredLocalExports.add(element.name.text);
+                }
+              });
             }
           });
         }
@@ -148,37 +160,57 @@ export class BarrelParser {
     if (spec.forwardedNamedExports.has(targetSymbolName)) {
       const routingRule = spec.forwardedNamedExports.get(targetSymbolName);
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, routingRule.targetModule);
-      return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      if (fullyResolvedPath) {
+        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, routingRule.sourceSymbol, activeProjectGraph, protectionStack);
+      }
     }
 
-    // Rule C: Evaluate structural namespace alias groupings
-    if (spec.namespacedWildcardExports.has(targetSymbolName)) {
-      const relativeModule = spec.namespacedWildcardExports.get(targetSymbolName);
-      const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
-      return { originFile: fullyResolvedPath, originSymbol: '*' };
+    // Rule C: Evaluate structural namespace alias groupings (export * as name from 'module')
+    for (const [namespaceAlias, relativeModule] of spec.namespacedWildcardExports.entries()) {
+      // If the targetSymbolName is prefixed with the namespaceAlias, then it's a member of this namespace re-export
+      if (targetSymbolName.startsWith(`${namespaceAlias}.`)) {
+        const originalSymbol = targetSymbolName.substring(namespaceAlias.length + 1);
+        const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativeModule);
+        if (fullyResolvedPath) {
+          return this.determineSymbolDeclarationOrigin(fullyResolvedPath, originalSymbol, activeProjectGraph, protectionStack);
+        }
+      }
     }
 
-    // Rule D: Sweep through anonymous star re-exports vectors
+    // Rule D: Sweep through anonymous star re-exports vectors (export * from 'module')
+    //
+    // Algorithm:
+    // 1. For each `export * from './child'`, recursively resolve the symbol in the child.
+    // 2. A non-barrel child immediately returns `{ originFile: childPath }` regardless of
+    //    whether it actually declares the symbol.  We therefore must verify that the
+    //    returned origin file actually contains the symbol in its declaredLocalExports
+    //    before accepting the result.
+    // 3. If the child is itself a barrel, the recursive call already performs the full
+    //    chain walk, so we only need to verify the final origin.
     for (const relativePath of spec.wildcardExports) {
       const fullyResolvedPath = this.resolver.resolveModulePath(contextFilePath, relativePath);
       
-      // Look inside the graph metadata map configuration to verify child target availability
-      const targetSubSpec = await this.parseBarrelSpecification(fullyResolvedPath);
-      
-      if (targetSubSpec.declaredLocalExports.has(targetSymbolName) || 
-          targetSubSpec.forwardedNamedExports.has(targetSymbolName)) {
-        return this.determineSymbolDeclarationOrigin(fullyResolvedPath, targetSymbolName, activeProjectGraph, protectionStack);
-      }
-
-      // Dynamic recursive trace for multi-tier nested barrel file layouts
-      if (targetSubSpec.isBarrelInstance) {
+      if (fullyResolvedPath) {
         const continuousResolutionTrace = await this.determineSymbolDeclarationOrigin(
           fullyResolvedPath,
           targetSymbolName,
           activeProjectGraph,
-          protectionStack
+          new Set(protectionStack) // Use a copy so sibling branches don't block each other
         );
-        if (continuousResolutionTrace && continuousResolutionTrace.originFile !== fullyResolvedPath) {
+
+        if (!continuousResolutionTrace) continue;
+        if (continuousResolutionTrace.originFile === contextFilePath) continue;
+
+        // Verify that the resolved origin actually declares the symbol.
+        // This prevents a non-barrel sibling (e.g. constants.ts) from being
+        // incorrectly returned for a symbol it does not export (e.g. formatData).
+        const originSpec = await this.parseBarrelSpecification(continuousResolutionTrace.originFile);
+        if (originSpec.declaredLocalExports.has(continuousResolutionTrace.originSymbol)) {
+          return continuousResolutionTrace;
+        }
+        // The origin spec is itself a barrel (isBarrelInstance = true) and the
+        // recursive call already resolved through it – accept the result.
+        if (originSpec.isBarrelInstance) {
           return continuousResolutionTrace;
         }
       }