@eventra_dev/eventra-cli 0.3.11 → 0.3.13

package/dist/cli/watch.js

@@ -41,10 +41,12 @@ async function watch() {
         try {
             const abs = normalize(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
+            // processFile extracts import specifiers for chokidar tracking;
+            // the engine itself receives raw file content.
             const parsed = await (0, processFile_1.processFile)(abs, raw);
             cache.set(abs, parsed);
             trackedFiles.add(abs);
-            await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), parsed.content);
+            await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(abs), raw);
             fileDeps.set(abs, new Set(parsed.dependencies
                 .filter((dep) => dep.startsWith(".") || dep.startsWith("/"))
                 .map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(abs), dep)))));
@@ -68,10 +70,13 @@ async function watch() {
         for (const file of batch) {
             try {
                 const raw = await promises_1.default.readFile(file, "utf-8");
+                // processFile here is used ONLY to extract import specifiers for
+                // chokidar's dependency tracking. The engine receives raw content
+                // and parses it itself.
                 const parsed = await (0, processFile_1.processFile)(file, raw);
                 cache.set(file, parsed);
                 trackedFiles.add(file);
-                await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content, config);
+                await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(file), raw, config);
                 const abs = normalize(file);
                 const prevDeps = fileDeps.get(abs) ?? new Set();
                 const nextDeps = new Set(parsed.dependencies

package/dist/compiler/compilerContext.js

@@ -8,7 +8,6 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 const documentRegistry_1 = require("./documentRegistry");
-const processFile_1 = require("../filesystem/processFile");
 class CompilerContext {
     rootDir;
     registry = new documentRegistry_1.DocumentRegistry();
@@ -137,10 +136,10 @@ class CompilerContext {
     flushUpdates() {
         this.rebuildProgram();
     }
-    async updateFile(fileName, content) {
+    // accept content as-is; the engine layer is responsible for parsing via processFile
+    updateFile(fileName, content) {
         const normalized = this.normalize(fileName);
-        const processed = await (0, processFile_1.processFile)(normalized, content);
-        this.stageFile(processed.fileName, processed.content);
+        this.stageFile(normalized, content);
         this.rebuildProgram();
     }
     removeFile(fileName) {

package/dist/core/EventraEngine.js

@@ -13,7 +13,6 @@ const evaluationCache_1 = require("../analysis/cache/evaluationCache");
 const resolvedCallCache_1 = require("../analysis/cache/resolvedCallCache");
 const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
-const symbolInvalidation_1 = require("../analysis/cache/symbolInvalidation");
 const analyzeFile_1 = require("../analysis/engine/analyzeFile");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
 const processFile_1 = require("../filesystem/processFile");
@@ -46,22 +45,52 @@ class EventraEngine {
         this.compiler = new compilerContext_1.CompilerContext(rootDir);
         this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry(this.compiler.getChecker(), this.resolvedExportCache);
         this.scheduler = new scheduler_1.Scheduler(async (updates) => {
-            const affected = new Set();
+            const changedFiles = new Set();
             for (const [file, content] of updates) {
-                const existing = this.compiler.getSourceFile(file);
-                if (existing) {
-                    (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache, this.returnPropagationCache, this.wrapperRegistry);
-                }
                 await this.compiler.updateFile(file, content);
                 this.updateImportGraph(file);
+                changedFiles.add(file);
+            }
+            // Program was rebuilt → every ts.Symbol from the previous program is now
+            // dead. WeakMap-keyed caches (incl. WrapperRegistry) must be dropped before
+            // we touch any NEW symbols, otherwise cross-file wrapper lookups miss.
+            this.resetCaches();
+            this.refreshChecker();
+            // Full re-index: WrapperRegistry must contain entries keyed by NEW
+            // symbols for every file, otherwise affected files cannot resolve
+            // wrappers defined in unaffected files (this is the watch-corruption bug).
+            this.reindexAll(this.lastConfig);
+            // Incremental extract: only re-extract changed files + their dependents.
+            // Unaffected files keep their previously-computed Set<string> events,
+            // which is safe (just strings, no AST refs).
+            const affected = new Set();
+            for (const file of changedFiles) {
                 affected.add(file);
                 for (const dependent of this.importGraph.collectDependents(file)) {
                     affected.add(dependent);
                 }
             }
-            await this.reanalyzeFiles([...affected], this.lastConfig);
+            for (const file of affected) {
+                this.extractFile(file, this.lastConfig);
+            }
         });
     }
+    // drop every symbol-keyed cache; call after a program rebuild
+    resetCaches() {
+        this.evaluationCache.clear();
+        this.resolvedCallCache.clear();
+        this.resolvedExportCache.clear();
+        this.returnPropagationCache.clear();
+        this.wrapperRegistry.clear();
+    }
+    // re-index every source file in the current program (skips .d.ts)
+    reindexAll(config) {
+        const sources = this.compiler.getAllSourceFiles();
+        this.fileIndices.clear();
+        for (const sf of sources) {
+            this.indexFile(sf.fileName, config);
+        }
+    }
     beginPreload() {
         this.isPreloading = true;
     }
@@ -137,11 +166,13 @@ class EventraEngine {
     }
     async reanalyzeFiles(fileNames, config) {
         this.lastConfig = config;
+        // Same correctness contract as the scheduler flush: the program may have
+        // just been rebuilt (e.g. via removeFile), so clear symbol caches and
+        // re-index every file before re-extracting the requested slice.
+        this.resetCaches();
         this.refreshChecker();
+        this.reindexAll(config);
         const normalized = fileNames.map((f) => this.normalize(f));
-        for (const file of normalized) {
-            this.indexFile(file, config);
-        }
         for (const file of normalized) {
             this.extractFile(file, config);
         }
@@ -175,10 +206,6 @@ class EventraEngine {
     }
     async removeFile(fileName, config) {
         const normalized = this.normalize(fileName);
-        const existing = this.compiler.getSourceFile(normalized);
-        if (existing) {
-            (0, symbolInvalidation_1.invalidateSourceFileSymbols)(existing, this.compiler.getChecker(), this.evaluationCache, this.resolvedCallCache, this.resolvedExportCache, this.returnPropagationCache, this.wrapperRegistry);
-        }
         const affected = this.importGraph.collectDependents(normalized);
         this.importGraph.removeFile(normalized);
         this.compiler.removeFile(normalized);
@@ -188,9 +215,17 @@ class EventraEngine {
         this.normalizedPathCache.delete(normalized);
         const nextConfig = config ?? this.lastConfig;
         const toReanalyze = [...affected].filter((f) => f !== normalized);
+        // reanalyzeFiles already resets caches + reindexes all sources,
+        // which is what we need after compiler.removeFile rebuilds the program.
         if (toReanalyze.length > 0) {
             await this.reanalyzeFiles(toReanalyze, nextConfig);
         }
+        else {
+            // Even without dependents, the program changed → caches must be reset
+            // so the next call (e.g. runFullAnalysis) sees a clean slate.
+            this.resetCaches();
+            this.refreshChecker();
+        }
     }
     getAllEvents() {
         const events = new Set();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "0.3.11",
+  "version": "0.3.13",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "type": "commonjs",