@eventra_dev/eventra-cli 2.1.0 → 2.2.0

package/dist/core/EventraEngine.js

@@ -15,7 +15,6 @@ const resolvedExportCache_1 = require("../analysis/cache/resolvedExportCache");
 const returnPropagationCache_1 = require("../analysis/cache/returnPropagationCache");
 const analyzeFile_1 = require("../analysis/engine/analyzeFile");
 const wrapperRegistry_1 = require("../analysis/symbols/wrapperRegistry");
-const processFile_1 = require("../filesystem/processFile");
 const loadPlugins_1 = require("../plugin/loadPlugins");
 const EMPTY_RESULT = () => ({
     events: new Set(),
@@ -34,6 +33,10 @@ class EventraEngine {
     fileIndices = new Map();
     fileResults = new Map();
     normalizedPathCache = new Map();
+    // files whose events count (the scanned sources); files that are in the
+    // program only because something imports them are never extracted, as in a
+    // fresh scan
+    scannedFiles = new Set();
     plugins;
     isPreloading = false;
     lastConfig = {
@@ -47,14 +50,32 @@ class EventraEngine {
     constructor(rootDir, plugins = (0, loadPlugins_1.createBuiltinPluginRegistry)()) {
         this.plugins = plugins;
         this.compiler = new compilerContext_1.CompilerContext(rootDir);
-        this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry(this.compiler.getChecker(), this.resolvedExportCache);
+        // resolved lazily: asking for the checker now would build the program
+        this.wrapperRegistry = new wrapperRegistry_1.WrapperRegistry(() => this.compiler.getChecker(), this.resolvedExportCache);
         this.scheduler = new scheduler_1.Scheduler(async (updates) => {
             const changedFiles = new Set();
+            // a file the graph has not seen yet changes what other files' imports resolve to
+            let fileSetChanged = false;
+            // Stage every file, rebuild the program ONCE, then refresh the import
+            // graph against that final program (one rebuild per flush, not per file).
             for (const [file, content] of updates) {
-                await this.compiler.updateFile(file, content);
-                this.updateImportGraph(file);
+                if (!this.importGraph.hasFile(file))
+                    fileSetChanged = true;
+                this.scannedFiles.add(file);
+                this.compiler.stageFile(file, content);
                 changedFiles.add(file);
             }
+            this.compiler.flushUpdates();
+            const edgeChanged = new Set();
+            this.compiler.withResolutionCache(() => {
+                for (const file of changedFiles) {
+                    this.updateImportGraph(file);
+                }
+            });
+            if (fileSetChanged) {
+                for (const file of this.refreshImportEdges(changedFiles))
+                    edgeChanged.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.
@@ -64,18 +85,20 @@ class EventraEngine {
             // 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.
+            // Incremental extract: only re-extract changed files + their dependents
+            // (+ files whose imports now resolve differently, and 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) {
+            for (const file of [...changedFiles, ...edgeChanged]) {
                 affected.add(file);
                 for (const dependent of this.importGraph.collectDependents(file)) {
                     affected.add(dependent);
                 }
             }
             for (const file of affected) {
-                this.extractFile(file, this.lastConfig);
+                if (this.scannedFiles.has(file))
+                    this.extractFile(file, this.lastConfig);
             }
         });
     }
@@ -107,12 +130,14 @@ class EventraEngine {
         this.normalizedPathCache.set(fileName, normalized);
         return normalized;
     }
+    // true when the file's resolved imports changed
     updateImportGraph(fileName) {
         const normalized = this.normalize(fileName);
         const source = this.compiler.getSourceFile(normalized);
         if (!source) {
+            const known = this.importGraph.hasFile(normalized);
             this.importGraph.removeFile(normalized);
-            return;
+            return known;
         }
         const imports = [];
         for (const statement of source.statements) {
@@ -132,22 +157,45 @@ class EventraEngine {
             }
             imports.push(this.normalize(resolved));
         }
-        this.importGraph.updateFile(normalized, imports);
+        return this.importGraph.updateFile(normalized, imports);
+    }
+    /**
+     * Creating or deleting a file can change what OTHER files' imports resolve to,
+     * without those files changing: an import written before its target existed
+     * starts to resolve, a deleted target stops. Their edges are re-resolved
+     * against the current program; the files whose imports changed are returned
+     * so they get analysed again (the graph alone cannot know about them: the
+     * reverse edge of a file that did not exist was never recorded).
+     */
+    refreshImportEdges(skip) {
+        const changed = new Set();
+        this.compiler.withResolutionCache(() => {
+            for (const file of this.importGraph.getFiles()) {
+                if (skip.has(file))
+                    continue;
+                if (this.updateImportGraph(file))
+                    changed.add(file);
+            }
+        });
+        return changed;
     }
     async preloadFile(fileName, content) {
         if (!this.isPreloading) {
             throw new Error("preload phase not active");
         }
         const normalized = this.normalize(fileName);
-        const processed = await (0, processFile_1.processFile)(normalized, content);
-        this.compiler.stageFile(processed.fileName, processed.content);
+        // processFile only echoed fileName/content back (its dependency list was
+        // unused here), so stage directly instead of parsing the file a second time.
+        this.compiler.stageFile(normalized, content);
     }
     endPreload() {
         this.isPreloading = false;
         this.compiler.flushUpdates();
-        for (const sourceFile of this.compiler.getAllSourceFiles()) {
-            this.updateImportGraph(sourceFile.fileName);
-        }
+        this.compiler.withResolutionCache(() => {
+            for (const sourceFile of this.compiler.getAllSourceFiles()) {
+                this.updateImportGraph(sourceFile.fileName);
+            }
+        });
     }
     async updateFile(fileName, content, config) {
         this.lastConfig = config;
@@ -162,6 +210,7 @@ class EventraEngine {
         this.refreshChecker();
         const normalized = fileNames.map((f) => this.normalize(f));
         for (const file of normalized) {
+            this.scannedFiles.add(file);
             this.indexFile(file, config);
         }
         for (const file of normalized) {
@@ -178,8 +227,62 @@ class EventraEngine {
         this.reindexAll(config);
         const normalized = fileNames.map((f) => this.normalize(f));
         for (const file of normalized) {
-            this.extractFile(file, config);
+            if (this.scannedFiles.has(file))
+                this.extractFile(file, config);
+        }
+    }
+    /**
+     * Files that are only imported (not scanned, e.g. `shared/events.ts` outside
+     * `include`) changed on disk, appeared or vanished. Their content is re-read
+     * (one program rebuild for the whole batch), the import graph is refreshed and
+     * the scanned files that depend on them are analysed again, so a long-running
+     * engine agrees with a fresh scan. Returns false when no content changed.
+     */
+    async refreshExternalFiles(fileNames, config) {
+        this.lastConfig = config;
+        const normalized = fileNames.map((f) => this.normalize(f));
+        // dependents are read before the edges change
+        const affected = new Set();
+        for (const file of normalized) {
+            for (const dependent of this.importGraph.collectDependents(file)) {
+                affected.add(dependent);
+            }
+        }
+        const changed = this.compiler.refreshFromDisk(normalized);
+        if (changed.length === 0) {
+            return false;
+        }
+        this.compiler.withResolutionCache(() => {
+            for (const file of changed) {
+                this.updateImportGraph(file);
+            }
+        });
+        // importers that had no edge before (a missing target appeared) or lost it
+        // (the target vanished), and everything depending on them
+        for (const file of this.refreshImportEdges(new Set(changed))) {
+            affected.add(file);
+            for (const dependent of this.importGraph.collectDependents(file)) {
+                affected.add(dependent);
+            }
         }
+        for (const file of changed) {
+            for (const dependent of this.importGraph.collectDependents(file)) {
+                affected.add(dependent);
+            }
+        }
+        for (const file of changed) {
+            affected.delete(file);
+        }
+        await this.reanalyzeFiles([...affected], config);
+        return true;
+    }
+    /** True when the file is in the program (scanned or only imported). */
+    hasProgramFile(fileName) {
+        return this.compiler.hasFile(this.normalize(fileName));
+    }
+    /** Project files in the program, for watching those that live outside the project root. */
+    getProjectFileNames() {
+        return this.compiler.getProjectFileNames();
     }
     indexFile(fileName, _config) {
         const normalized = this.normalize(fileName);
@@ -204,6 +307,7 @@ class EventraEngine {
     }
     async scanFile(fileName, config) {
         this.lastConfig = config;
+        this.scannedFiles.add(this.normalize(fileName));
         this.refreshChecker();
         this.indexFile(fileName, config);
         return this.extractFile(fileName, config);
@@ -215,8 +319,16 @@ class EventraEngine {
         this.compiler.removeFile(normalized);
         this.fileIndices.delete(normalized);
         this.fileResults.delete(normalized);
+        this.scannedFiles.delete(normalized);
         this.normalizedPathCache.delete(fileName);
         this.normalizedPathCache.delete(normalized);
+        // importers of the removed file now resolve differently (and another file
+        // may now win a resolution the removed one was shadowing)
+        for (const file of this.refreshImportEdges(new Set([normalized]))) {
+            for (const dependent of this.importGraph.collectDependents(file)) {
+                affected.add(dependent);
+            }
+        }
         const nextConfig = config ?? this.lastConfig;
         const toReanalyze = [...affected].filter((f) => f !== normalized);
         // reanalyzeFiles already resets caches + reindexes all sources,
@@ -259,7 +371,8 @@ class EventraEngine {
         for (const result of this.fileResults.values()) {
             occurrences.push(...result.dynamicOccurrences);
         }
-        return occurrences.sort((a, b) => a.fileName.localeCompare(b.fileName) || a.line - b.line);
+        const byText = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
+        return occurrences.sort((a, b) => byText(a.fileName, b.fileName) || a.line - b.line || a.character - b.character);
     }
 }
 exports.EventraEngine = EventraEngine;

package/dist/core/catalogMeta.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPullRequestBuild = isPullRequestBuild;
+exports.detectBranch = detectBranch;
+exports.countUnresolved = countUnresolved;
+exports.collectCatalogMeta = collectCatalogMeta;
+const child_process_1 = require("child_process");
+const projectScanner_1 = require("./projectScanner");
+const MAX_BRANCH_LENGTH = 200;
+// CI systems usually check out a detached HEAD, so git cannot name the branch
+// there; these variables can. First one set wins.
+const BRANCH_ENV_VARS = [
+    "GITHUB_REF_NAME",
+    "CI_COMMIT_REF_NAME",
+    "BRANCH_NAME",
+    "BITBUCKET_BRANCH",
+    "CIRCLE_BRANCH",
+    "BUILDKITE_BRANCH",
+    "VERCEL_GIT_COMMIT_REF",
+];
+// A pull / merge request build checks out the PROPOSED code: a PR that deletes
+// an event must not mark it removed on the project catalog.
+const PULL_REQUEST_MARKERS = [
+    (env) => env.GITHUB_EVENT_NAME === "pull_request" || env.GITHUB_EVENT_NAME === "pull_request_target",
+    (env) => (env.GITHUB_REF ?? "").startsWith("refs/pull/"),
+    (env) => Boolean(env.CI_MERGE_REQUEST_IID) || env.CI_PIPELINE_SOURCE === "merge_request_event",
+    (env) => Boolean(env.BITBUCKET_PR_ID),
+    (env) => Boolean(env.CIRCLE_PULL_REQUEST || env.CIRCLE_PR_NUMBER),
+    (env) => Boolean(env.BUILDKITE_PULL_REQUEST) && env.BUILDKITE_PULL_REQUEST !== "false",
+    (env) => Boolean(env.VERCEL_GIT_PULL_REQUEST_ID),
+    (env) => Boolean(env.TRAVIS_PULL_REQUEST) && env.TRAVIS_PULL_REQUEST !== "false",
+    (env) => Boolean(env.SYSTEM_PULLREQUEST_PULLREQUESTID) || env.BUILD_REASON === "PullRequest",
+    (env) => Boolean(env.CHANGE_ID),
+];
+/** True when the environment says this run is a pull / merge request build. */
+function isPullRequestBuild(env = process.env) {
+    return PULL_REQUEST_MARKERS.some((marker) => marker(env));
+}
+/** Best-effort current branch. Never throws; returns undefined when unknown. */
+function detectBranch(env = process.env, cwd = process.cwd()) {
+    for (const name of BRANCH_ENV_VARS) {
+        const value = env[name]?.trim();
+        if (value)
+            return value.slice(0, MAX_BRANCH_LENGTH);
+    }
+    try {
+        const out = (0, child_process_1.execFileSync)("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            cwd,
+            encoding: "utf8",
+            timeout: 3000,
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        // "HEAD" is what git prints for a detached checkout: not a branch name
+        if (out && out !== "HEAD")
+            return out.slice(0, MAX_BRANCH_LENGTH);
+    }
+    catch {
+        // not a git checkout, git missing or too slow
+    }
+    return undefined;
+}
+function sameSet(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const set = new Set(a);
+    return b.every((value) => set.has(value));
+}
+// An Angular template module embeds a copy of its component class, so the same
+// call is reported twice: once from the class file and once from that copy
+// (inGeneratedCode). Only the real one is counted.
+function countUnresolved(occurrences) {
+    return occurrences.filter((o) => o.resolvedValues.length === 0 && !o.inGeneratedCode).length;
+}
+/**
+ * Scans the project again to find out whether the event list about to be sent
+ * is complete. Never throws: any failure means complete = false.
+ */
+async function collectCatalogMeta(config) {
+    const branch = detectBranch();
+    const withBranch = (meta) => (branch ? { ...meta, branch } : meta);
+    try {
+        const { engine, skipped } = await (0, projectScanner_1.scanProject)(config);
+        const scanned = engine.getAllEvents();
+        const dynamicCount = countUnresolved(engine.getAllDynamicOccurrences());
+        const complete = skipped.length === 0 && !isPullRequestBuild() && sameSet(config.events ?? [], scanned);
+        return withBranch({ complete, dynamicCount });
+    }
+    catch {
+        return withBranch({ complete: false });
+    }
+}

package/dist/core/fileLimits.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OVERSIZED_REASON = exports.MAX_FILE_CHARS = void 0;
+exports.isOversized = isOversized;
+// Files above this size are generated or vendored output (bundles, minified
+// code, big fixtures), not something to analyse. One limit for every command,
+// so `sync` and `watch` can never disagree about a file.
+exports.MAX_FILE_CHARS = 2_000_000;
+exports.OVERSIZED_REASON = "file is larger than 2 MB";
+function isOversized(content) {
+    return content.length > exports.MAX_FILE_CHARS;
+}

package/dist/core/projectScanner.js

@@ -12,59 +12,47 @@ const EventraEngine_1 = require("./EventraEngine");
 const processFile_1 = require("../filesystem/processFile");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
 const loadPlugins_1 = require("../plugin/loadPlugins");
+const scanFilters_1 = require("./scanFilters");
+const skipped_1 = require("./skipped");
+const fileLimits_1 = require("./fileLimits");
 const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
-async function getParsedFile(file, cache) {
-    const existing = cache.get(file);
-    if (existing)
-        return existing;
-    const raw = await promises_1.default.readFile(file, "utf8");
-    const parsed = await (0, processFile_1.processFile)(file, raw);
-    cache.set(file, parsed);
-    return parsed;
-}
 async function scanProject(config) {
     const plugins = await (0, loadPlugins_1.createPluginRegistry)(config);
     const include = [...config.sync.include, ...plugins.getIncludePatterns()];
     const files = await (0, fast_glob_1.default)(include, {
-        ignore: config.sync.exclude,
+        ignore: (0, scanFilters_1.expandExcludePatterns)(config.sync.exclude),
         absolute: true,
     });
     const engine = new EventraEngine_1.EventraEngine(process.cwd(), plugins);
     const cache = new Map();
     const toScan = new Set();
+    const skipped = [];
+    const ignored = [];
     for (const file of files) {
         try {
             const raw = await promises_1.default.readFile(file, "utf8");
-            if (raw.length > 2_000_000)
+            if ((0, fileLimits_1.isOversized)(raw)) {
+                ignored.push({ file, reason: fileLimits_1.OVERSIZED_REASON });
                 continue;
+            }
             const virtualFiles = await plugins.preprocessFile({ fileName: file, content: raw });
             for (const virtualFile of virtualFiles) {
                 const parsed = await (0, processFile_1.processFile)(virtualFile.fileName, virtualFile.content);
                 const scanPath = path_1.default.resolve(virtualFile.fileName);
                 cache.set(scanPath, parsed);
                 toScan.add(scanPath);
-                for (const dep of parsed.dependencies) {
-                    if (dep.startsWith(".") || dep.startsWith("/")) {
-                        toScan.add(path_1.default.resolve(path_1.default.dirname(scanPath), dep));
-                    }
-                }
             }
         }
         catch (err) {
-            console.error(`skip: ${file}`, err instanceof Error ? err.message : err);
+            skipped.push((0, skipped_1.skippedFrom)(file, err));
         }
     }
     const virtualFiles = [SDK_TYPES_FILE, ...toScan].map((f) => (0, getVirtualFile_1.getVirtualFile)(f));
     engine.beginPreload();
     await engine.preloadFile(SDK_TYPES_FILE, eventraSdk_1.EVENTRA_SDK_SHIM);
     for (const file of toScan) {
-        try {
-            const parsed = await getParsedFile(file, cache);
-            await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), parsed.content);
-        }
-        catch (err) {
-            console.error(`preload skip: ${file}`, err instanceof Error ? err.message : err);
-        }
+        // every path in toScan was parsed and cached in the loop above
+        await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(file), cache.get(file).content);
     }
     engine.endPreload();
     await engine.runFullAnalysis(virtualFiles, config);
@@ -77,5 +65,7 @@ async function scanProject(config) {
         results,
         files,
         plugins,
+        skipped,
+        ignored,
     };
 }

package/dist/core/scanFilters.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandExcludePatterns = expandExcludePatterns;
+exports.globToRegExp = globToRegExp;
+exports.toPosix = toPosix;
+exports.createFileFilter = createFileFilter;
+const path_1 = __importDefault(require("path"));
+const GLOB_CHARS = /[*?[\]{}()!]/;
+/**
+ * `sync.exclude` entries are written as bare directory names (`node_modules`,
+ * `dist`). fast-glob only matches a bare name against the repo root, so a
+ * nested `packages/x/node_modules` would still be scanned. A plain name is
+ * therefore expanded to match at any depth; entries that already contain a
+ * `/` or glob characters are left exactly as written.
+ */
+function expandExcludePatterns(exclude) {
+    const out = new Set();
+    for (const entry of exclude) {
+        const pattern = entry.trim();
+        if (!pattern)
+            continue;
+        if (pattern.includes("/") || GLOB_CHARS.test(pattern)) {
+            out.add(pattern);
+        }
+        else {
+            out.add(`**/${pattern}`);
+            out.add(`**/${pattern}/**`);
+        }
+    }
+    return [...out];
+}
+// fast-glob runs with dot:false: `*`, `**` and `?` never match a path segment
+// that starts with a dot (.svelte-kit, .nuxt, .turbo, ...) unless the glob
+// spells the dot itself (`.github/**`). The watch filter must agree, or
+// generated output in those directories leaks in while `sync` ignores it.
+const NO_DOT = "(?!\\.)";
+/** Converts the glob subset used by eventra configs (`**`, `*`, `?`, `{a,b}`, `[..]`) to a RegExp. */
+function globToRegExp(glob) {
+    const source = glob.replace(/^\.\//, "");
+    let out = "";
+    let braceDepth = 0;
+    // a segment starts at the beginning, after a slash, or at a brace alternative
+    const atSegmentStart = (i) => i === 0 || "/{,".includes(source[i - 1]);
+    for (let i = 0; i < source.length; i++) {
+        const ch = source[i];
+        if (ch === "*") {
+            if (source[i + 1] === "*") {
+                if (source[i + 2] === "/" && atSegmentStart(i)) {
+                    // zero or more whole segments, none of them hidden
+                    out += `(?:${NO_DOT}[^/]+/)*`;
+                    i += 2;
+                }
+                else if (i + 2 >= source.length && atSegmentStart(i)) {
+                    // trailing `**`: everything below, again without hidden segments
+                    out += `(?:${NO_DOT}[^/]+/)*(?:${NO_DOT}[^/]*)?`;
+                    i += 1;
+                }
+                else {
+                    out += ".*";
+                    i += 1;
+                }
+            }
+            else {
+                out += `${atSegmentStart(i) ? NO_DOT : ""}[^/]*`;
+            }
+        }
+        else if (ch === "?") {
+            out += `${atSegmentStart(i) ? NO_DOT : ""}[^/]`;
+        }
+        else if (ch === "{") {
+            braceDepth++;
+            out += "(?:";
+        }
+        else if (ch === "}" && braceDepth > 0) {
+            braceDepth--;
+            out += ")";
+        }
+        else if (ch === "," && braceDepth > 0) {
+            out += "|";
+        }
+        else if (ch === "[") {
+            const end = source.indexOf("]", i + 1);
+            if (end === -1) {
+                out += "\\[";
+            }
+            else {
+                out += source.slice(i, end + 1);
+                i = end;
+            }
+        }
+        else {
+            out += ch.replace(/[.+^$()|\\\]]/g, "\\$&");
+        }
+    }
+    return new RegExp(`^${out}$`);
+}
+function toPosix(file) {
+    return file.replace(/\\/g, "/");
+}
+/**
+ * Mirrors what the initial fast-glob scan accepts, so watch mode reacts to the
+ * same files as `sync`.
+ */
+function createFileFilter(include, exclude, cwd, alwaysExcluded = []) {
+    const includeRes = include.filter((p) => !p.startsWith("!")).map(globToRegExp);
+    const negatedRes = include
+        .filter((p) => p.startsWith("!"))
+        .map((p) => globToRegExp(p.slice(1)));
+    const excludeRes = exclude
+        .map((p) => p.trim())
+        .filter(Boolean)
+        .map((p) => {
+        const globbed = p.includes("/") || GLOB_CHARS.test(p) ? p : `**/${p}`;
+        return globToRegExp(globbed.replace(/\/+$/, ""));
+    });
+    const relative = (absPath) => toPosix(path_1.default.relative(cwd, absPath));
+    const isExcluded = (absPath) => {
+        const rel = relative(absPath);
+        if (alwaysExcluded.includes(rel))
+            return true;
+        const segments = rel.split("/");
+        // test every leading prefix so a match on a directory excludes what is inside it
+        for (let n = 1; n <= segments.length; n++) {
+            const prefix = segments.slice(0, n).join("/");
+            if (excludeRes.some((re) => re.test(prefix)))
+                return true;
+        }
+        return false;
+    };
+    return {
+        isExcluded,
+        isIncluded(absPath) {
+            const rel = relative(absPath);
+            if (rel === ".." || rel.startsWith("../") || path_1.default.isAbsolute(rel))
+                return false;
+            if (isExcluded(absPath))
+                return false;
+            if (negatedRes.some((re) => re.test(rel)))
+                return false;
+            return includeRes.some((re) => re.test(rel));
+        },
+    };
+}

package/dist/core/scanResults.js

@@ -3,16 +3,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildConfigFromScan = buildConfigFromScan;
 exports.persistScanResults = persistScanResults;
 const config_1 = require("../config/config");
-function buildConfigFromScan(config, engine) {
-    const functionWrappers = engine
-        .getAllFunctionWrappers()
-        .map((name) => ({ name }));
+const uniqueSorted = (values) => [...new Set(values)].sort();
+function buildConfigFromScan(config, engine, options = {}) {
+    const foundWrappers = engine.getAllFunctionWrappers();
+    const foundEvents = engine.getAllEvents();
+    if (options.preserveKnown) {
+        return {
+            ...config,
+            events: uniqueSorted([...(config.events ?? []), ...foundEvents]),
+            functionWrappers: uniqueSorted([
+                ...(config.functionWrappers ?? []).map((w) => w.name),
+                ...foundWrappers,
+            ]).map((name) => ({ name })),
+        };
+    }
+    const functionWrappers = foundWrappers.map((name) => ({ name }));
     return {
         ...config,
-        events: engine.getAllEvents(),
+        events: foundEvents,
         functionWrappers,
     };
 }
-async function persistScanResults(config, engine) {
-    await (0, config_1.saveConfig)(buildConfigFromScan(config, engine));
+async function persistScanResults(config, engine, options = {}) {
+    const next = buildConfigFromScan(config, engine, options);
+    await (0, config_1.saveConfig)(next);
+    // what is now in eventra.json: callers report these counts
+    return (0, config_1.normalizeConfig)(next);
 }