@eventra_dev/eventra-cli 0.1.24 → 0.1.26

package/dist/commands/check.js

@@ -7,9 +7,11 @@ exports.check = check;
 const chalk_1 = __importDefault(require("chalk"));
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+const getVirtualFile_1 = require("../utils/getVirtualFile");
 async function check({ fix = false }) {
     const config = await (0, config_1.loadConfig)();
     if (!config) {
@@ -19,37 +21,59 @@ async function check({ fix = false }) {
     console.log(chalk_1.default.blue("Checking events..."));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
+    const toScan = new Set();
+    const cache = new Map();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
-            const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-            engine.scanFile(virtualFile, content, config);
-            for (const dep of deps) {
-                try {
-                    const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                    const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
-                    engine.scanFile(depVirtual, depContent, config);
-                }
-                catch { }
+            if (raw.length > 2_000_000)
+                continue;
+            const parsed = (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.deps) {
+                toScan.add(path_1.default.resolve(dep));
             }
         }
-        catch (err) {
-            console.log(chalk_1.default.yellow(`Skipped: ${file}`));
+        catch { }
+    }
+    // PRELOAD
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile(virtual, parsed.content);
+        }
+        catch { }
+    }
+    // SCAN
+    for (const file of toScan) {
+        try {
+            const parsed = cache.get(file);
+            if (!parsed)
+                continue;
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.scanFile(virtual, parsed.content, config);
         }
+        catch { }
     }
+    // DIFF
     const found = new Set(engine.getAllEvents());
     const known = new Set(config.events ?? []);
     const newEvents = [...found].filter(e => !known.has(e));
     const removed = [...known].filter(e => !found.has(e));
     // FIX MODE
     if (fix) {
-        const next = new Set();
-        found.forEach(e => next.add(e));
-        newEvents.forEach(e => console.log(chalk_1.default.green(`+ ${e}`)));
-        removed.forEach(e => console.log(chalk_1.default.red(`- ${e}`)));
-        config.events = [...next].sort();
+        config.events = [...found].sort();
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.green(`\nSynced (${config.events.length} events)`));
         return;

package/dist/commands/sync.js

@@ -7,9 +7,11 @@ exports.sync = sync;
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = __importDefault(require("fs/promises"));
 const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
+const getVirtualFile_1 = require("../utils/getVirtualFile");
 async function sync() {
     const config = await (0, config_1.loadConfig)();
     if (!config)
@@ -17,73 +19,73 @@ async function sync() {
     console.log(chalk_1.default.blue("Scanning..."));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     if (!files.length) {
         console.log(chalk_1.default.yellow("No files found"));
         return;
     }
     const engine = new engine_1.EventraEngine(process.cwd());
-    const detectedFn = new Set();
-    const detectedCmp = new Map();
-    const fileCache = [];
+    const toScan = new Set();
+    const cache = new Map();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf-8");
-            const { content, virtualFile, deps } = (0, processFile_1.processFile)(file, raw);
-            engine["ts"].updateFile(virtualFile, content);
-            fileCache.push({ file: virtualFile, content });
-            // deps
-            for (const dep of deps) {
-                try {
-                    const depRaw = await promises_1.default.readFile(dep, "utf-8");
-                    const { content: depContent, virtualFile: depVirtual, } = (0, processFile_1.processFile)(dep, depRaw);
-                    engine["ts"].updateFile(depVirtual, depContent);
-                    fileCache.push({ file: depVirtual, content: depContent });
-                }
-                catch { }
+            if (raw.length > 2_000_000)
+                continue;
+            const parsed = (0, processFile_1.processFile)(file, raw);
+            cache.set(file, parsed);
+            toScan.add(file);
+            for (const dep of parsed.deps) {
+                toScan.add(path_1.default.resolve(dep));
             }
         }
         catch { }
     }
-    for (const { file, content } of fileCache) {
+    // PRELOAD
+    for (const file of toScan) {
         try {
-            const res = engine.scanFile(file, content, config);
-            for (const w of res.detectedFunctionWrappers) {
-                detectedFn.add(w);
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
             }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile(virtual, parsed.content);
+        }
+        catch { }
+    }
+    // SCAN
+    const detectedFn = new Set();
+    const detectedCmp = new Map();
+    for (const file of toScan) {
+        try {
+            const parsed = cache.get(file);
+            if (!parsed)
+                continue;
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            const res = engine.scanFile(virtual, parsed.content, config);
+            res.detectedFunctionWrappers.forEach(w => detectedFn.add(w));
             for (const [k, v] of res.detectedComponentWrappers) {
                 detectedCmp.set(k, v);
             }
         }
-        catch (err) {
-            console.log(chalk_1.default.yellow(`Skipped: ${file}`));
-            if (err instanceof Error) {
-                console.log(chalk_1.default.gray(err.message));
-            }
+        catch {
+            console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
-    // EVENTS
+    // RESULT
     const events = engine.getAllEvents().sort();
-    const mergedEvents = new Set(config.events ?? []);
-    events.forEach(e => mergedEvents.add(e));
-    config.events = [...mergedEvents].sort();
-    // FUNCTION WRAPPERS
+    config.events = events;
     config.functionWrappers = mergeUnique(config.functionWrappers ?? [], [...detectedFn].map(name => ({ name })), w => w.name);
-    // COMPONENT WRAPPERS
     config.wrappers = mergeUnique(config.wrappers ?? [], [...detectedCmp.entries()].map(([name, prop]) => ({
         name,
         prop,
     })), w => `${w.name}:${w.prop}`);
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.green(`Found ${events.length} events`));
-    if (detectedFn.size) {
-        console.log(chalk_1.default.blue("\nDetected function wrappers:"));
-        detectedFn.forEach(w => console.log(chalk_1.default.gray(`• ${w}`)));
-    }
-    if (detectedCmp.size) {
-        console.log(chalk_1.default.blue("\nDetected component wrappers:"));
-        detectedCmp.forEach((prop, name) => console.log(chalk_1.default.gray(`• ${name} (${prop})`)));
-    }
 }
 // HELPERS
 function mergeUnique(a, b, key) {

package/dist/commands/watch.js

@@ -12,11 +12,9 @@ const path_1 = __importDefault(require("path"));
 const config_1 = require("../utils/config");
 const engine_1 = require("../engine/engine");
 const processFile_1 = require("../utils/processFile");
-// stabile virtual mapping
-function getVirtualFile(file) {
-    return /\.(vue|svelte|astro|html)$/i.test(file)
-        ? file + ".tsx"
-        : file;
+const getVirtualFile_1 = require("../utils/getVirtualFile");
+function normalize(file) {
+    return path_1.default.resolve(file).replace(/\\/g, "/");
 }
 async function watch() {
     const config = await (0, config_1.loadConfig)();
@@ -25,58 +23,108 @@ async function watch() {
     console.log(chalk_1.default.blue("Watching...\n"));
     const files = await (0, fast_glob_1.default)(config.sync.include, {
         ignore: config.sync.exclude,
+        absolute: true,
     });
     const engine = new engine_1.EventraEngine(process.cwd());
     const watchedDeps = new Set();
-    // INITIAL LOAD
+    const cache = new Map();
+    const toScan = new Set();
+    // COLLECT + CACHE
     for (const file of files) {
         try {
-            const abs = path_1.default.resolve(file);
+            const abs = normalize(file);
             const raw = await promises_1.default.readFile(abs, "utf-8");
-            const { content, deps } = (0, processFile_1.processFile)(abs, raw);
-            const virtual = getVirtualFile(abs);
-            engine.scanFile(virtual, content, config);
-            // deps
-            for (const dep of deps) {
-                watchedDeps.add(path_1.default.resolve(dep));
+            if (raw.length > 2_000_000)
+                continue;
+            const parsed = (0, processFile_1.processFile)(abs, raw);
+            cache.set(abs, parsed);
+            toScan.add(abs);
+            for (const dep of parsed.deps) {
+                toScan.add(normalize(dep));
             }
         }
         catch {
             console.log(chalk_1.default.gray(`skip: ${file}`));
         }
     }
+    // PRELOAD
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+                cache.set(file, parsed);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.preloadFile?.(virtual, parsed.content);
+        }
+        catch { }
+    }
+    // INITIAL SCAN
+    for (const file of toScan) {
+        try {
+            let parsed = cache.get(file);
+            if (!parsed) {
+                const raw = await promises_1.default.readFile(file, "utf-8");
+                parsed = (0, processFile_1.processFile)(file, raw);
+            }
+            const virtual = (0, getVirtualFile_1.getVirtualFile)(file);
+            engine.scanFile(virtual, parsed.content, config);
+            for (const dep of parsed.deps) {
+                watchedDeps.add(normalize(dep));
+            }
+        }
+        catch { }
+    }
     config.events = engine.getAllEvents().sort();
     await (0, config_1.saveConfig)(config);
     console.log(chalk_1.default.gray(`Initial: ${config.events.length} events\n`));
     // QUEUE
     let locked = false;
-    let queued = new Map();
+    const queued = new Map();
     let timer = null;
     const run = async () => {
-        if (locked) {
-            timer = setTimeout(run, 100);
+        if (locked)
             return;
-        }
         locked = true;
         const batch = [...queued.values()];
         queued.clear();
         for (const item of batch) {
             try {
                 const raw = await promises_1.default.readFile(item.real, "utf-8");
-                const { content, deps } = (0, processFile_1.processFile)(item.real, raw);
-                engine.updateFile(item.virtual, content, config);
-                // DEPS
-                for (const dep of deps) {
-                    const absDep = path_1.default.resolve(dep);
-                    if (!watchedDeps.has(absDep)) {
-                        watcher.add(absDep);
-                        watchedDeps.add(absDep);
+                if (raw.length > 2_000_000)
+                    continue;
+                const parsed = (0, processFile_1.processFile)(item.real, raw);
+                cache.set(item.real, parsed);
+                engine.updateFile(item.virtual, parsed.content, config);
+                // DEPENDENCY DIFF
+                const nextDeps = new Set();
+                for (const dep of parsed.deps) {
+                    nextDeps.add(normalize(dep));
+                }
+                // add new deps
+                for (const dep of nextDeps) {
+                    if (!watchedDeps.has(dep)) {
+                        watcher.add(dep);
+                        watchedDeps.add(dep);
                     }
+                }
+                // remove old deps
+                for (const dep of [...watchedDeps]) {
+                    if (!nextDeps.has(dep)) {
+                        watcher.unwatch(dep);
+                        watchedDeps.delete(dep);
+                    }
+                }
+                // preload deps
+                for (const dep of nextDeps) {
                     try {
-                        const depRaw = await promises_1.default.readFile(absDep, "utf-8");
-                        const { content: depContent } = (0, processFile_1.processFile)(absDep, depRaw);
-                        const depVirtual = getVirtualFile(absDep);
-                        engine.updateFile(depVirtual, depContent, config);
+                        const raw = await promises_1.default.readFile(dep, "utf-8");
+                        const parsedDep = (0, processFile_1.processFile)(dep, raw);
+                        cache.set(dep, parsedDep);
+                        const virtual = (0, getVirtualFile_1.getVirtualFile)(dep);
+                        engine.updateFile(virtual, parsedDep.content, config);
                     }
                     catch { }
                 }
@@ -85,7 +133,7 @@ async function watch() {
                 console.log(chalk_1.default.gray(`skip: ${item.real}`));
             }
         }
-        // EVENTS DIFF
+        // DIFF EVENTS
         const next = engine.getAllEvents();
         const added = next.filter(e => !config.events.includes(e));
         const removed = config.events.filter(e => !next.includes(e));
@@ -100,33 +148,39 @@ async function watch() {
     };
     // SCHEDULER
     const schedule = (file) => {
-        const abs = path_1.default.resolve(file);
-        const virtual = getVirtualFile(abs);
+        const abs = normalize(file);
+        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
+        console.log(chalk_1.default.gray(`change: ${file}`));
         queued.set(abs, { real: abs, virtual });
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 300);
+        timer = setTimeout(run, 200);
     };
     // WATCHER
     const watcher = chokidar_1.default.watch(config.sync.include, {
         ignored: config.sync.exclude,
         ignoreInitial: true,
+        persistent: true,
     });
     watcher
         .on("add", schedule)
         .on("change", schedule)
         .on("unlink", async (file) => {
-        const abs = path_1.default.resolve(file);
+        const abs = normalize(file);
         console.log(chalk_1.default.gray(`remove: ${file}`));
-        const virtual = getVirtualFile(abs);
+        const virtual = (0, getVirtualFile_1.getVirtualFile)(abs);
         engine.removeFile(virtual, config);
+        watcher.unwatch(abs);
         watchedDeps.delete(abs);
         const next = engine.getAllEvents();
         config.events = next.sort();
         await (0, config_1.saveConfig)(config);
         console.log(chalk_1.default.gray(`Total: ${config.events.length} events\n`));
+    })
+        .on("error", (err) => {
+        console.error(chalk_1.default.red("Watcher error:"), err);
     });
-    // WATCH DEPS
+    // WATCH DEPS INIT
     for (const dep of watchedDeps) {
         watcher.add(dep);
     }

package/dist/engine/callResolver.js

@@ -23,15 +23,37 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
         const aliased = checker.getAliasedSymbol(symbol);
         return resolveFromSymbol(aliased, checker, visited, depth + 1);
     }
+    // re-export support
+    if (symbol.exports) {
+        for (const exp of symbol.exports.values()) {
+            const resolved = resolveFromSymbol(exp, checker, visited, depth + 1);
+            if (resolved)
+                return resolved;
+        }
+    }
     const decls = symbol.getDeclarations() ?? [];
     for (const decl of decls) {
+        // direct function
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // MethodSignature
+        // VARIABLE → FUNCTION
+        if (typescript_1.default.isVariableDeclaration(decl) && decl.initializer) {
+            if (isFunctionLike(decl.initializer)) {
+                return decl.initializer;
+            }
+            const innerSymbol = checker.getSymbolAtLocation(decl.initializer);
+            if (innerSymbol && innerSymbol !== symbol) {
+                const resolved = resolveFromSymbol(innerSymbol, checker, visited, depth + 1);
+                if (resolved)
+                    return resolved;
+            }
+        }
+        // MethodSignature (interface / type)
         if (typescript_1.default.isMethodSignature(decl)) {
             const parent = decl.parent;
-            if (typescript_1.default.isInterfaceDeclaration(parent) || typescript_1.default.isTypeLiteralNode(parent)) {
+            if (typescript_1.default.isInterfaceDeclaration(parent) ||
+                typescript_1.default.isTypeLiteralNode(parent)) {
                 const name = decl.name.getText();
                 const type = checker.getTypeAtLocation(parent);
                 const props = type.getProperties();
@@ -44,7 +66,7 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
                 }
             }
         }
-        // SAFE fallback
+        // fallback recursion
         const s = checker.getSymbolAtLocation(decl);
         if (s && s !== symbol) {
             const resolved = resolveFromSymbol(s, checker, visited, depth + 1);
@@ -55,6 +77,28 @@ function resolveFromSymbol(symbol, checker, visited = new Set(), depth = 0) {
     return null;
 }
 function resolveFunctionFromCall(expr, checker) {
+    // tracker.track
+    if (typescript_1.default.isPropertyAccessExpression(expr)) {
+        let symbol = checker.getSymbolAtLocation(expr.name);
+        if (symbol && (symbol.flags & typescript_1.default.SymbolFlags.Alias)) {
+            symbol = checker.getAliasedSymbol(symbol);
+        }
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // tracker["track"]
+    if (typescript_1.default.isElementAccessExpression(expr)) {
+        const symbol = checker.getSymbolAtLocation(expr.argumentExpression);
+        if (symbol) {
+            const resolved = resolveFromSymbol(symbol, checker);
+            if (resolved)
+                return resolved;
+        }
+    }
+    // normal call signatures
     const type = checker.getTypeAtLocation(expr);
     const signatures = type.getCallSignatures();
     for (const sig of signatures) {
@@ -64,7 +108,6 @@ function resolveFunctionFromCall(expr, checker) {
         if (isFunctionLike(decl)) {
             return decl;
         }
-        // interface method
         if (typescript_1.default.isMethodSignature(decl)) {
             const symbol = checker.getSymbolAtLocation(decl.name);
             if (symbol) {
@@ -74,5 +117,10 @@ function resolveFunctionFromCall(expr, checker) {
             }
         }
     }
+    // fallback
+    const symbol = checker.getSymbolAtLocation(expr);
+    if (symbol) {
+        return resolveFromSymbol(symbol, checker);
+    }
     return null;
 }

package/dist/engine/engine.js

@@ -1,6 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.EventraEngine = void 0;
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
 const languageService_1 = require("./languageService");
 const scanner_1 = require("./scanner");
 const graph_1 = require("./graph");
@@ -16,28 +21,40 @@ class EventraEngine {
         const { baseUrl, paths } = this.ts.getModuleResolutionConfig();
         this.graph = new graph_1.DependencyGraph(baseUrl, paths);
     }
+    normalize(file) {
+        return path_1.default.resolve(file).replace(/\\/g, "/");
+    }
+    empty() {
+        return {
+            events: new Set(),
+            detectedFunctionWrappers: new Set(),
+            detectedComponentWrappers: new Map(),
+        };
+    }
+    // PRELOAD
+    preloadFile(file, content) {
+        file = this.normalize(file);
+        this.ts.updateFile(file, content);
+        const source = this.ts.getSourceFile(file);
+        if (source) {
+            this.graph.update(file, source);
+        }
+    }
     // SCAN FILE
     scanFile(file, content, config) {
+        file = this.normalize(file);
         const h = (0, hash_1.hash)(content);
-        // skip unchanged
         if (this.fileHash.get(file) === h) {
-            return (this.fileResults.get(file) ?? {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            });
+            return this.fileResults.get(file) ?? this.empty();
         }
         this.fileHash.set(file, h);
         this.ts.updateFile(file, content);
         const source = this.ts.getSourceFile(file);
         const checker = this.ts.getChecker();
         if (!source || !checker) {
-            return {
-                events: new Set(),
-                detectedFunctionWrappers: new Set(),
-                detectedComponentWrappers: new Map(),
-            };
+            return this.empty();
         }
+        // обновляем graph
         this.graph.update(file, source);
         const res = (0, scanner_1.scanSource)(source, checker, config);
         this.fileResults.set(file, res);
@@ -45,27 +62,35 @@ class EventraEngine {
     }
     // UPDATE FILE (incremental)
     updateFile(file, content, config) {
-        // сначала обновляем текущий файл
+        file = this.normalize(file);
         const res = this.scanFile(file, content, config);
         const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const depContent = this.ts.getFileContent(dep);
-            if (!depContent)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let depContent = this.ts.getFileContent(abs);
+            if (!depContent) {
+                try {
+                    depContent = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(depContent);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h) {
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, depContent);
-            const source = this.ts.getSourceFile(dep);
+            }
+            this.fileHash.set(abs, h);
+            this.ts.updateFile(abs, depContent);
+            const source = this.ts.getSourceFile(abs);
             const checker = this.ts.getChecker();
             if (!source || !checker)
                 continue;
-            this.graph.update(dep, source);
+            this.graph.update(abs, source);
             const r = (0, scanner_1.scanSource)(source, checker, config);
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
         return res;
     }
@@ -79,33 +104,42 @@ class EventraEngine {
     }
     // REMOVE FILE
     removeFile(file, config) {
+        file = this.normalize(file);
+        const dependents = this.graph.getAllDependentsDeep(file);
         this.ts.removeFile(file);
         this.fileResults.delete(file);
         this.fileHash.delete(file);
         this.graph.remove(file);
-        const dependents = this.graph.getAllDependentsDeep(file);
         for (const dep of dependents) {
-            if ((0, boundary_1.isExternalFile)(dep))
-                continue;
-            const content = this.ts.getFileContent(dep);
-            if (!content)
+            const abs = this.normalize(dep);
+            if ((0, boundary_1.isExternalFile)(abs))
                 continue;
+            let content = this.ts.getFileContent(abs);
+            if (!content) {
+                try {
+                    content = fs_1.default.readFileSync(abs, "utf-8");
+                }
+                catch {
+                    continue;
+                }
+            }
             const h = (0, hash_1.hash)(content);
-            if (this.fileHash.get(dep) === h)
+            if (this.fileHash.get(abs) === h)
                 continue;
-            this.fileHash.set(dep, h);
-            this.ts.updateFile(dep, content);
-            const source = this.ts.getSourceFile(dep);
+            this.fileHash.set(abs, h);
+            this.ts.updateFile(abs, content);
+            const source = this.ts.getSourceFile(abs);
             const checker = this.ts.getChecker();
             if (!source || !checker)
                 continue;
+            this.graph.update(abs, source);
             const r = (0, scanner_1.scanSource)(source, checker, config ?? {
                 events: [],
                 wrappers: [],
                 functionWrappers: [],
                 sync: { include: [], exclude: [] },
             });
-            this.fileResults.set(dep, r);
+            this.fileResults.set(abs, r);
         }
     }
 }