pkg-scaffold 2.4.0 → 3.1.0

package/src/ast/MagicDetector.js

@@ -1,66 +1,23 @@
 import path from 'path';
 import fs from 'fs/promises';
+import { PluginRegistry } from '../plugins/PluginRegistry.js';
 
 /**
  * Ecosystem Entry Point Manifest & Dynamic Framework Router Heuristic Validator
  * Intercepts implicit conventions to handle cases where direct import statements are absent.
+ * Now refactored to use a pluggable architecture.
  */
 export class MagicDetector {
   constructor(context) {
     this.context = context;
-    this.manifestSchemaRules = this.compileEcosystemSchemaMatrices();
+    this.registry = new PluginRegistry(context);
+    this.isInitialized = false;
   }
 
-  /**
-   * Compiles explicit layout definitions to handle various web development environments.
-   */
-  compileEcosystemSchemaMatrices() {
-    return {
-      nextjs: {
-        configFiles: ['next.config.js', 'next.config.mjs', 'next.config.ts'],
-        routePatterns: [
-          /\/pages\/api\//,
-          /\/pages\/[a-zA-Z0-9_\-\[\]]+/i,
-          /\/app\/([\w\-\[\]]+\/)+(page|route|layout|loading|error|not-found)\.(ts|tsx|js|jsx)$/
-        ],
-        requiredSystemContracts: ['default', 'getServerSideProps', 'getStaticProps', 'getStaticPaths', 'generateMetadata', 'middleware']
-      },
-      nuxt: {
-        configFiles: ['nuxt.config.js', 'nuxt.config.ts'],
-        routePatterns: [
-          /\/pages\//,
-          /\/server\/(api|routes|middleware)\//,
-          /\/components\/[a-zA-Z0-9_\-\/]+\.vue$/
-        ],
-        requiredSystemContracts: ['default']
-      },
-      remix: {
-        configFiles: ['remix.config.js', 'vite.config.js', 'vite.config.ts'],
-        routePatterns: [
-          /\/app\/routes\//,
-          /\/app\/root\.(tsx|jsx)$/
-        ],
-        requiredSystemContracts: ['default', 'loader', 'action', 'meta', 'links']
-      },
-      sveltekit: {
-        configFiles: ['svelte.config.js', 'vite.config.ts'],
-        routePatterns: [
-          /\+page\.(svelte|ts|js)$/,
-          /\+page\.server\.(ts|js)$/,
-          /\+layout\.(svelte|ts|js)$/,
-          /\+server\.(ts|js)$/
-        ],
-        requiredSystemContracts: ['load', 'actions', 'GET', 'POST', 'PUT', 'DELETE', 'PATCH']
-      },
-      astro: {
-        configFiles: ['astro.config.mjs', 'astro.config.cjs', 'astro.config.ts'],
-        routePatterns: [
-          /\/src\/pages\/.*\.astro$/,
-          /\/src\/pages\/.*\.(ts|js)$/
-        ],
-        requiredSystemContracts: ['default', 'getStaticPaths']
-      }
-    };
+  async ensureInitialized(baseDir) {
+    if (this.isInitialized) return;
+    await this.registry.init(baseDir || process.cwd());
+    this.isInitialized = true;
   }
 
   /**
@@ -68,19 +25,9 @@ export class MagicDetector {
    * @param {string} baseContextDirectory - Root file workspace context execution vector path
    */
   async identifyActiveProjectEcosystems(baseContextDirectory) {
-    const activeFrameworkFlags = [];
-    
-    for (const [frameworkKey, criteria] of Object.entries(this.manifestSchemaRules)) {
-      for (const configFile of criteria.configFiles) {
-        try {
-          await fs.access(path.join(baseContextDirectory, configFile));
-          activeFrameworkFlags.push(frameworkKey);
-          break; // Stop scanning once config criteria is found
-        } catch {
-          // File path criteria absent; proceed to standard verification loops
-        }
-      }
-    }
+    await this.ensureInitialized(baseContextDirectory);
+    const activePlugins = await this.registry.getActivePlugins(baseContextDirectory);
+    const activeFrameworkFlags = activePlugins.map(p => p.name);
     
     // Universal infrastructure overrides (testing platforms and common bundlers)
     activeFrameworkFlags.push('universal-tooling-vectors');
@@ -90,15 +37,18 @@ export class MagicDetector {
   /**
    * Assesses if a file path acts as an implicit route entry point.
    */
-  isImplicitlyRequiredByEcosystem(absolutePath, activeFrameworks) {
+  async isImplicitlyRequiredByEcosystem(absolutePath, activeFrameworks, baseDir) {
+    await this.ensureInitialized();
     const normalizedSystemPath = absolutePath.replace(/\\/g, '/');
 
-    for (const framework of activeFrameworks) {
-      const frameworkRules = this.manifestSchemaRules[framework];
-      if (!frameworkRules) continue;
-
-      const matchesPattern = frameworkRules.routePatterns.some(regex => regex.test(normalizedSystemPath));
-      if (matchesPattern) return true;
+    const plugins = this.registry.getPlugins();
+    for (const plugin of plugins) {
+      if (activeFrameworks.includes(plugin.name)) {
+        const patterns = plugin.getRoutePatterns();
+        if (patterns.some(regex => regex.test(normalizedSystemPath))) {
+          return true;
+        }
+      }
     }
 
     // Apply baseline platform rules (Test suites, lint parameters, continuous integration files)
@@ -117,7 +67,8 @@ export class MagicDetector {
     const testEnvironments = [
       'jest.config.', 'vitest.config.', 'playwright.config.', 'cypress.config.',
       'webpack.config.', 'vite.config.', 'rollup.config.', 'tailwind.config.',
-      '.eslintrc.', 'prettier.config.', '.postcssrc.', 'postcss.config.'
+      '.eslintrc.', 'prettier.config.', '.postcssrc.', 'postcss.config.',
+      'bin/cli.js', 'index.js', 'WorkerTaskRunner.js'
     ];
     
     return testEnvironments.some(matchPattern => normalizedPath.includes(matchPattern));
@@ -126,28 +77,31 @@ export class MagicDetector {
   /**
    * Challenge #4 Framework Overrides. Protects interface boundaries from false positive report flags.
    */
-  injectVirtualConsumerEdges(filePath, fileNode, activeFrameworks) {
-    if (!this.isImplicitlyRequiredByEcosystem(filePath, activeFrameworks)) return;
+  async injectVirtualConsumerEdges(filePath, fileNode, activeFrameworks) {
+    await this.ensureInitialized();
+    if (!await this.isImplicitlyRequiredByEcosystem(filePath, activeFrameworks)) return;
 
     // Retain entry point elements within memory to keep verification safe
     fileNode.isLibraryEntry = true;
 
     // Apply dynamic exports coverage metrics based on active platform contracts
     const normalizedPath = filePath.replace(/\\/g, '/');
+    const plugins = this.registry.getPlugins();
 
-    for (const framework of activeFrameworks) {
-      const frameworkRules = this.manifestSchemaRules[framework];
-      if (!frameworkRules) continue;
-
-      // If the file path matches the active framework schema, protect its interface keywords
-      const appliesToFramework = frameworkRules.routePatterns.some(regex => regex.test(normalizedPath));
-      if (appliesToFramework) {
-        frameworkRules.requiredSystemContracts.forEach(contractMethodToken => {
-          if (fileNode.internalExports.has(contractMethodToken)) {
-            // Emulate active local reference linkages to protect the export
-            fileNode.instantiatedIdentifiers.add(contractMethodToken);
-          }
-        });
+    for (const plugin of plugins) {
+      if (activeFrameworks.includes(plugin.name)) {
+        const patterns = plugin.getRoutePatterns();
+        const appliesToFramework = patterns.some(regex => regex.test(normalizedPath));
+        
+        if (appliesToFramework) {
+          const contracts = plugin.getRequiredSystemContracts();
+          contracts.forEach(contractMethodToken => {
+            if (fileNode.internalExports.has(contractMethodToken)) {
+              // Emulate active local reference linkages to protect the export
+              fileNode.instantiatedIdentifiers.add(contractMethodToken);
+            }
+          });
+        }
       }
     }
   }

package/src/ast/OxcAnalyzer.js

@@ -0,0 +1,114 @@
+import { parseSync } from 'oxc-parser';
+import fs from 'fs/promises';
+
+/**
+ * High-Performance AST Analyzer using OXC (Rust-based)
+ * Designed to outpace Knip v6 by utilizing the fastest parser in the JS ecosystem.
+ */
+export class OxcAnalyzer {
+  constructor(context) {
+    this.context = context;
+  }
+
+  async processFile(filePath, fileNode) {
+    try {
+      const sourceText = await fs.readFile(filePath, 'utf8');
+      
+      // OXC is significantly faster than TypeScript for single-pass analysis
+      const { program } = parseSync(sourceText, {
+        sourceFilename: filePath,
+        sourceType: filePath.endsWith('.ts') || filePath.endsWith('.tsx') ? 'typescript' : 'script'
+      });
+
+      this.walkOxcNode(program, fileNode);
+      return true;
+    } catch (err) {
+      if (this.context.verbose) {
+        console.error(`[OXC Error] Failed parsing: ${filePath}. Reason: ${err.message}`);
+      }
+      return false;
+    }
+  }
+
+  walkOxcNode(node, fileNode) {
+    if (!node) return;
+
+    // OXC AST structure is slightly different from TS
+    // We focus on imports, exports, and namespace members
+    if (node.type === 'ImportDeclaration') {
+      const specifier = node.source.value;
+      fileNode.explicitImports.add(specifier);
+      node.specifiers.forEach(s => {
+        if (s.type === 'ImportSpecifier') {
+          fileNode.importedSymbols.add(`${specifier}:${s.imported.name}`);
+        } else if (s.type === 'ImportDefaultSpecifier') {
+          fileNode.importedSymbols.add(`${specifier}:default`);
+        } else if (s.type === 'ImportNamespaceSpecifier') {
+          fileNode.importedSymbols.add(`${specifier}:*`);
+        }
+      });
+    }
+
+    if (node.type === 'ExportNamedDeclaration') {
+      if (node.declaration) {
+        this.handleOxcDeclaration(node.declaration, fileNode);
+      }
+      if (node.specifiers) {
+        node.specifiers.forEach(s => {
+          fileNode.internalExports.set(s.exported.name, { type: 'export-specifier' });
+        });
+      }
+    }
+
+    if (node.type === 'ExportDefaultDeclaration') {
+      fileNode.internalExports.set('default', { type: 'default-export' });
+    }
+
+    // Phase 3: Namespace Member Tracking
+    if (node.type === 'TSModuleDeclaration' && node.id.type === 'Identifier') {
+      const namespaceName = node.id.name;
+      if (node.body && node.body.type === 'TSModuleBlock') {
+        node.body.body.forEach(innerNode => {
+          if (innerNode.type === 'ExportNamedDeclaration' && innerNode.declaration) {
+             const decl = innerNode.declaration;
+             let memberName;
+             if (decl.type === 'VariableDeclaration') {
+               memberName = decl.declarations[0].id.name;
+             } else if (decl.id) {
+               memberName = decl.id.name;
+             }
+             if (memberName) {
+               fileNode.namespaceMembers = fileNode.namespaceMembers || new Set();
+               fileNode.namespaceMembers.add(`${namespaceName}.${memberName}`);
+             }
+          }
+        });
+      }
+    }
+
+    // Recursively walk
+    for (const key in node) {
+      const child = node[key];
+      if (child && typeof child === 'object') {
+        if (Array.isArray(child)) {
+          child.forEach(c => this.walkOxcNode(c, fileNode));
+        } else {
+          this.walkOxcNode(child, fileNode);
+        }
+      }
+    }
+  }
+
+  handleOxcDeclaration(decl, fileNode) {
+    let name;
+    if (decl.type === 'FunctionDeclaration' || decl.type === 'ClassDeclaration' || decl.type === 'TSEnumDeclaration' || decl.type === 'TSInterfaceDeclaration' || decl.type === 'TSTypeAliasDeclaration') {
+      name = decl.id?.name;
+    } else if (decl.type === 'VariableDeclaration') {
+      name = decl.declarations[0].id.name;
+    }
+    
+    if (name) {
+      fileNode.internalExports.set(name, { type: decl.type.toLowerCase() });
+    }
+  }
+}

package/src/healing/SelfHealer.js

@@ -29,7 +29,7 @@ export class SelfHealer {
       await refactorTask();
 
       // Step 3: Stage changes inside our Git tracking context
-      await this.gitSandbox.checkpointChanges();
+      await this.gitSandbox.stageAndCheckpointChanges();
 
       console.log('🧪 Running testing suites to verify workspace integrity...');
       const validationPassed = await this.verifyProjectHealthStatus();

package/src/index.js

@@ -9,6 +9,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import ansis from 'ansis';
+import readline from 'readline/promises';
 
 // Import local domain architecture sub-systems
 import { EngineContext } from './EngineContext.js';
@@ -16,17 +17,17 @@ import { ASTAnalyzer } from './ast/ASTAnalyzer.js';
 import { BarrelParser } from './ast/BarrelParser.js';
 import { MagicDetector } from './ast/MagicDetector.js';
 import { PathMapper } from './resolution/PathMapper.js';
-import { WorkspaceGraph } from './resolution/WorkspaceGraph.js';
-import { DependencyResolver } from './resolution/DependencyResolver.js';
-import { TransactionManager } from './refactor/TransactionManager.js';
-import { ImpactAnalyzer } from './refactor/ImpactAnalyzer.js';
-import { SourceRewriter } from './refactor/SourceRewriter.js';
-import { TypeIntegrity } from './refactor/TypeIntegrity.js';
+import { WorkspaceGraph } from './resolution/WorkSpaceGraph.js';
+import { DependencyResolver } from './resolution/DepencyResolver.js';
+import { TransactionManager } from './refractor/TransactionManager.js';
+import { ImpactAnalyzer } from './refractor/ImpactAnalyzer.js';
+import { SourceRewriter } from './refractor/SourceRewriter.js';
+import { TypeIntegrity } from './refractor/TypeIntegrity.js';
 import { GitSandbox } from './healing/GitSandbox.js';
 import { SelfHealer } from './healing/SelfHealer.js';
 import { IncrementalCacheManager } from './performance/GraphCache.js';
 import { WorkerPool } from './performance/WorkerPool.js';
-import { SupplyChainGuard } from './security/SupplyChainGuard.js';
+import { SupplyChainGuard } from './performance/SupplyChainGuard.js';
 
 /**
  * Primary Refactoring Engine Core Coordination Controller
@@ -67,6 +68,11 @@ export class RefactoringEngine {
     try {
       console.log(ansis.bold.green('🎯 Starting pkg-scaffold Operational Optimization Cycle...'));
       
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+      });
+      
       // Pass 1: Boot environment contexts and load alias configuration maps
       await this.context.initialize();
       await this.pathMapper.loadMappings(this.context.tsconfigFilename);
@@ -103,25 +109,32 @@ export class RefactoringEngine {
         parallelParseCompleted = await this.workerPool.parallelAnalyzeCodebase(sourceCodeFilesList, this);
       }
 
-      // Synchronous fallback loop to parse remaining files or cache misses
+      // Synchronous fallback loop to parse remaining files or cache misses.
+      // IMPORTANT: The `parallelParseCompleted` flag only controls whether the *worker pool*
+      // already processed all files. It must NOT be set per-file inside this loop — doing so
+      // would cause all files after the first cache-hit to be silently skipped.
       for (const filePath of sourceCodeFilesList) {
         const node = this.context.createNode(filePath);
         const currentHash = await this.cacheManager.computeHash(filePath);
         node.contentHash = currentHash;
 
-        if (cacheManifest[filePath] && cacheManifest[filePath].hash === currentHash) {
+        // Check if this individual file is already up-to-date in the cache
+        const isFileCached = cacheManifest[filePath] && cacheManifest[filePath].hash === currentHash;
+
+        if (isFileCached) {
           this.context.metrics.cacheHits++;
           this.hydrateNodeFromCache(node, cacheManifest[filePath]);
-          parallelParseCompleted = true; // Cached elements don't need worker allocations
-        }
-
-        if (!parallelParseCompleted) {
+        } else if (!parallelParseCompleted) {
+          // Only parse if the worker pool did not already handle this file
           this.context.metrics.cacheMisses++;
           await this.analyzer.processFile(filePath, node);
         }
 
         // Apply ecosystem overrides directly to our parsed memory maps
         this.magicDetector.injectVirtualConsumerEdges(filePath, node, activeFrameworkEcosystems);
+
+        // Aggregate used external packages for the dependency audit
+        node.externalPackageUsage.forEach(pkg => this.context.usedExternalPackages.add(pkg));
       }
 
       // Pass 4: Evaluate graph edges and link connections across the codebase mesh
@@ -139,45 +152,73 @@ export class RefactoringEngine {
           analysisSummary.structuralIssuesDetected.deadExports.length > 0;
 
         if (structuralModificationsStaged) {
-          await this.selfHealer.runSelfHealingLifecycle(async () => {
-            
-            // Sub-Task A: Purge completely unreferenced dangling components
-            for (const relPath of analysisSummary.structuralIssuesDetected.deadFiles) {
-              const absPath = path.resolve(this.context.cwd, relPath);
-              console.log(ansis.red(`✂️  Removing unreferenced file: ${relPath}`));
-              await this.txManager.stageDeletion(absPath);
-            }
-
-            // Sub-Task B: Surgically remove unused named export blocks from active files
-            for (const unusedExport of analysisSummary.structuralIssuesDetected.deadExports) {
-              const absPath = path.resolve(this.context.cwd, unusedExport.file);
-              const node = this.context.graph.get(absPath);
-              
-              if (!node) continue;
-              const meta = node.internalExports.get(unusedExport.symbol);
-
-              // Perform safety analysis to ensure the token isn't called via dynamic runtime methods
-              const safetyVerdict = await this.impactAnalyzer.verifyRefactorSafety(absPath, unusedExport.symbol, this.context.graph);
-
-              if (safetyVerdict.isSafeToPrune) {
-                console.log(ansis.yellow(`⚡ Stripping unused export [${unusedExport.symbol}] from: ${unusedExport.file}:${unusedExport.line}`));
-                const currentText = await fs.readFile(absPath, 'utf8');
-                const nextText = await this.sourceRewriter.stripNamedExportSignature(absPath, unusedExport.symbol, meta);
-                
-                await this.txManager.stageWrite(absPath, nextText);
+          console.log(ansis.bold.yellow('\n📋 Proposed Optimization Plan:'));
+          console.log(ansis.dim('------------------------------------------------------------'));
+          
+          if (analysisSummary.structuralIssuesDetected.deadFiles.length > 0) {
+            console.log(ansis.bold(`  🗑️  Delete ${analysisSummary.structuralIssuesDetected.deadFiles.length} orphaned files:`));
+            analysisSummary.structuralIssuesDetected.deadFiles.forEach(f => console.log(ansis.dim(`    • ${f}`)));
+          }
+          
+          if (analysisSummary.structuralIssuesDetected.deadExports.length > 0) {
+            console.log(ansis.bold(`  ✂️  Prune ${analysisSummary.structuralIssuesDetected.deadExports.length} unused named exports:`));
+            analysisSummary.structuralIssuesDetected.deadExports.forEach(e => console.log(ansis.dim(`    • ${e.symbol} in ${e.file}:${e.line}`)));
+          }
+
+          if (analysisSummary.structuralIssuesDetected.unusedDependencies.length > 0) {
+            console.log(ansis.bold(`  📦 Remove ${analysisSummary.structuralIssuesDetected.unusedDependencies.length} unused dependencies:`));
+            analysisSummary.structuralIssuesDetected.unusedDependencies.forEach(d => console.log(ansis.dim(`    • ${d.package} (in ${d.manifest})`)));
+          }
+          console.log(ansis.dim('------------------------------------------------------------'));
+
+          let proceed = this.context.skipConfirm;
+          if (!proceed) {
+            const answer = await rl.question(ansis.bold.cyan('\n❓ Apply these structural modifications? (y/N): '));
+            proceed = answer.toLowerCase() === 'y';
+          }
+
+          if (proceed) {
+            await this.selfHealer.runSelfHealingLifecycle(async () => {
+              // Sub-Task A: Purge completely unreferenced dangling components
+              for (const relPath of analysisSummary.structuralIssuesDetected.deadFiles) {
+                const absPath = path.resolve(this.context.cwd, relPath);
+                console.log(ansis.red(`✂️  Removing unreferenced file: ${relPath}`));
+                await this.txManager.stageDeletion(absPath);
+              }
+
+              // Sub-Task B: Surgically remove unused named export blocks from active files
+              for (const unusedExport of analysisSummary.structuralIssuesDetected.deadExports) {
+                const absPath = path.resolve(this.context.cwd, unusedExport.file);
+                const node = this.context.graph.get(absPath);
                 
-                // Align matching type declaration boundaries (.d.ts) to prevent compilation errors
-                await this.typeIntegrity.synchronizeDeclarationFile(absPath, unusedExport.symbol);
-              } else if (this.context.verbose) {
-                console.log(ansis.gray(`🛡️  Preserving symbol export [${unusedExport.symbol}] due to: ${safetyVerdict.blockReason}`));
+                if (!node) continue;
+                const meta = node.internalExports.get(unusedExport.symbol);
+
+                // Perform safety analysis to ensure the token isn't called via dynamic runtime methods
+                const safetyVerdict = await this.impactAnalyzer.verifyRefactorSafety(absPath, unusedExport.symbol, this.context.graph);
+
+                if (safetyVerdict.isSafeToPrune) {
+                  console.log(ansis.yellow(`⚡ Stripping unused export [${unusedExport.symbol}] from: ${unusedExport.file}:${unusedExport.line}`));
+                  const nextText = await this.sourceRewriter.stripNamedExportSignature(absPath, unusedExport.symbol, meta);
+                  
+                  await this.txManager.stageWrite(absPath, nextText);
+                  
+                  // Align matching type declaration boundaries (.d.ts) to prevent compilation errors
+                  await this.typeIntegrity.synchronizeDeclarationFile(absPath, unusedExport.symbol);
+                } else if (this.context.verbose) {
+                  console.log(ansis.gray(`🛡️  Preserving symbol export [${unusedExport.symbol}] due to: ${safetyVerdict.blockReason}`));
+                }
               }
-            }
-          });
+            });
+          } else {
+            console.log(ansis.bold.yellow('\n⚠️  Optimization plan aborted by user. No changes applied.'));
+          }
         }
       }
 
       // Pass 7: Save optimized graph footprints back to the cache directory
       await this.cacheManager.saveCacheManifest(this.context.graph);
+      rl.close();
       console.log(ansis.bold.green('\n✨ Core optimization cycle completed smoothly. Codebase workspace is healthy.'));
 
     } catch (criticalFault) {
@@ -240,6 +281,12 @@ export class RefactoringEngine {
       const devDeps = Object.keys(data.devDependencies || {});
       const totalDependencies = [...prodDeps, ...devDeps];
 
+      // Register dependencies for later audit
+      this.context.manifestDependencies.set(packageJsonPath, {
+        dependencies: prodDeps,
+        devDependencies: devDeps
+      });
+
       // Pass dependencies down to our Levenshtein string-distance guard to find typosquat targets
       const supplyChainThreats = this.supplyChainGuard.detectTyposquattingAnomalies(totalDependencies);
       
@@ -269,6 +316,17 @@ export class RefactoringEngine {
     }
     node.isLibraryEntry = cachedRecord.isLibraryEntry || false;
     node.securityThreats = cachedRecord.securityThreats || [];
+    if (cachedRecord.localSuppressedRules) {
+      cachedRecord.localSuppressedRules.forEach(r => node.localSuppressedRules.add(r));
+    }
+    if (cachedRecord.symbolSourceLocations) {
+      Object.entries(cachedRecord.symbolSourceLocations).forEach(([k, v]) => {
+        node.symbolSourceLocations.set(k, v);
+      });
+    }
+    if (cachedRecord.externalPackageUsage) {
+      cachedRecord.externalPackageUsage.forEach(p => node.externalPackageUsage.add(p));
+    }
   }
 
   /**
@@ -338,6 +396,15 @@ export class RefactoringEngine {
       });
     }
 
+    if (report.structuralIssuesDetected.unusedDependencies.length > 0) {
+      console.log(ansis.bold.red(`\nUnused External Dependencies Flagged (${report.structuralIssuesDetected.unusedDependencies.length}):`));
+      report.structuralIssuesDetected.unusedDependencies.forEach(d => {
+        console.log(`  • Package [${ansis.red(d.package)}] in ${ansis.dim(d.manifest)}`);
+      });
+    } else {
+      console.log(ansis.green('\n✨ No unused external dependencies found in manifest files.'));
+    }
+
     console.log(ansis.dim('\n============================================================\n'));
   }
 }

package/src/performance/GraphCache.js

@@ -63,7 +63,10 @@ export class IncrementalCacheManager {
         instantiatedIdentifiers: Array.from(node.instantiatedIdentifiers),
         propertyAccessChains: Array.from(node.propertyAccessChains),
         internalExports: Object.fromEntries(node.internalExports),
-        securityThreats: node.securityThreats || []
+        securityThreats: node.securityThreats || [],
+        localSuppressedRules: Array.from(node.localSuppressedRules),
+        symbolSourceLocations: Object.fromEntries(node.symbolSourceLocations),
+        externalPackageUsage: Array.from(node.externalPackageUsage)
       };
     }