@eventra_dev/eventra-cli 2.1.0 → 2.2.0

package/dist/cli/watch.js

@@ -14,141 +14,242 @@ const eventraSdk_1 = require("../analysis/sdk/eventraSdk");
 const EventraEngine_1 = require("../core/EventraEngine");
 const scanResults_1 = require("../core/scanResults");
 const loadPlugins_1 = require("../plugin/loadPlugins");
-const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
-const processFile_1 = require("../filesystem/processFile");
+const scanFilters_1 = require("../core/scanFilters");
+const skipped_1 = require("../core/skipped");
+const fileLimits_1 = require("../core/fileLimits");
 const getVirtualFile_1 = require("../filesystem/getVirtualFile");
+const SDK_TYPES_FILE = "__eventra_sdk_types__.d.ts";
+// Files outside `include` can still change what a scanned file means when
+// something imports them (a shared constants module, a wrapper in a helper).
+// Only code-like files are worth rebuilding the program for.
+const CODE_FILE = /\.(?:[cm]?[jt]s|[jt]sx|json)$/;
+const isNotFound = (err) => err?.code === "ENOENT";
 async function watch() {
-    const config = await (0, config_1.loadConfig)();
-    if (!config) {
-        console.log(chalk_1.default.red("eventra.json not found"));
-        return;
-    }
+    const config = await (0, config_1.requireConfig)();
+    if (!config)
+        return undefined;
     console.log(chalk_1.default.blue("Watching...\n"));
     const plugins = await (0, loadPlugins_1.createPluginRegistry)(config);
     const include = [...config.sync.include, ...plugins.getIncludePatterns()];
     const engine = new EventraEngine_1.EventraEngine(process.cwd(), plugins);
-    const fileDeps = new Map();
-    const cache = new Map();
     const watchedDeps = new Set();
     const trackedFiles = new Set();
     const sourceFiles = new Set();
+    // files whose last analysis failed; while there are any, saved results keep
+    // the previously known events (see buildConfigFromScan)
+    const skippedNow = new Map();
     const normalize = (file) => {
         return path_1.default.resolve(file).replace(/\\/g, "/");
     };
-    // chokidar's `ignored` receives absolute, normalized paths — reject any path
-    // with an excluded directory name as one of its segments (matches how
-    // `fast-glob`'s own `ignore` option is applied during the initial scan).
-    const excludedDirs = new Set(config.sync.exclude);
-    const isExcludedPath = (file) => {
-        const segments = normalize(file).split("/");
-        return segments.some((segment) => excludedDirs.has(segment));
+    // The same rules as the initial scan (and as `sync`): plain exclude names match
+    // at any depth, and a changed file is only handled when it matches `include`.
+    // The config files are written by this process, so they must never trigger a run.
+    const filter = (0, scanFilters_1.createFileFilter)(include, config.sync.exclude, process.cwd(), [
+        config_1.CONFIG_NAME,
+        config_1.LOCAL_CONFIG_NAME,
+    ]);
+    const isExcludedPath = (file) => filter.isExcluded(normalize(file));
+    const isSource = (abs) => sourceFiles.has(abs) || trackedFiles.has(abs) || filter.isIncluded(abs);
+    // an imported (or newly importable) file outside `include`
+    const isDependencyCandidate = (abs) => CODE_FILE.test(abs) && !isSource(abs);
+    const shouldHandle = (abs) => !filter.isExcluded(abs) && (isSource(abs) || isDependencyCandidate(abs));
+    // what eventra.json holds now: "keep the known events" while a file is broken
+    // must mean the events this process saved last, not the ones at startup
+    let saved = config;
+    const persist = async () => {
+        saved = await (0, scanResults_1.persistScanResults)(saved, engine, { preserveKnown: skippedNow.size > 0 });
     };
+    const signature = () => JSON.stringify([engine.getAllEvents(), engine.getAllFunctionWrappers()]);
     const files = await (0, fast_glob_1.default)(include, {
-        ignore: config.sync.exclude,
+        ignore: (0, scanFilters_1.expandExcludePatterns)(config.sync.exclude),
         absolute: true,
     });
+    const ignoredInitial = [];
     engine.beginPreload();
     await engine.preloadFile(SDK_TYPES_FILE, eventraSdk_1.EVENTRA_SDK_SHIM);
     for (const file of files) {
         try {
             const abs = normalize(file);
-            sourceFiles.add(abs);
             const raw = await promises_1.default.readFile(abs, "utf-8");
+            // the same limit as `sync`: too big to analyse, but not a failure
+            if ((0, fileLimits_1.isOversized)(raw)) {
+                ignoredInitial.push({ file: abs, reason: fileLimits_1.OVERSIZED_REASON });
+                continue;
+            }
+            sourceFiles.add(abs);
             const virtualFiles = await plugins.preprocessFile({ fileName: abs, content: raw });
             for (const virtualFile of virtualFiles) {
                 const scanPath = normalize(virtualFile.fileName);
-                const parsed = await (0, processFile_1.processFile)(scanPath, virtualFile.content);
-                cache.set(scanPath, parsed);
                 trackedFiles.add(scanPath);
                 await engine.preloadFile((0, getVirtualFile_1.getVirtualFile)(scanPath), virtualFile.content);
-                fileDeps.set(scanPath, new Set(parsed.dependencies
-                    .filter((dep) => dep.startsWith(".") || dep.startsWith("/"))
-                    .map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(scanPath), dep)))));
             }
         }
-        catch {
-            // ignore invalid files
+        catch (err) {
+            const skip = (0, skipped_1.skippedFrom)(file, err);
+            skippedNow.set(normalize(file), skip);
         }
     }
     engine.endPreload();
+    (0, skipped_1.reportSkipped)([...skippedNow.values()]);
+    (0, skipped_1.reportIgnored)(ignoredInitial);
     await engine.runFullAnalysis([SDK_TYPES_FILE, ...trackedFiles].map((f) => (0, getVirtualFile_1.getVirtualFile)(f)), config);
-    await (0, scanResults_1.persistScanResults)(config, engine);
+    await persist();
     const initialEvents = engine.getAllEvents();
     const initialWrappers = engine.getAllFunctionWrappers();
-    console.log(chalk_1.default.gray(`Initial: ${initialEvents.length} events, ${initialWrappers.length} wrappers\n`));
+    console.log(chalk_1.default.gray(`Initial: ${(0, skipped_1.plural)(initialEvents.length, "event")}, ${(0, skipped_1.plural)(initialWrappers.length, "wrapper")}\n`));
     // Watch the project root (not just the files found by the initial scan) so
-    // that brand-new files matching `include` are noticed as they're created —
+    // that brand-new files matching `include` are noticed as they're created -
     // a fixed file list only ever detects edits to files chokidar already knows
-    // about. Dependency files outside the root (added below via `watcher.add`)
-    // are unaffected by this and keep working the same way.
+    // about. Project files that live outside the root are added below.
     const watcher = chokidar_1.default.watch(process.cwd(), {
         ignoreInitial: true,
         ignored: isExcludedPath,
     });
+    const root = normalize(process.cwd());
+    const isOutsideRoot = (abs) => abs !== root && !abs.startsWith(`${root}/`);
+    // Imported files outside the project root are not covered by the root
+    // watcher: follow exactly the ones the program really resolved.
+    const syncOutsideDeps = () => {
+        const outside = new Set(engine
+            .getProjectFileNames()
+            .map(normalize)
+            .filter((file) => isOutsideRoot(file) && !filter.isExcluded(file) && CODE_FILE.test(file)));
+        for (const dep of outside) {
+            if (watchedDeps.has(dep))
+                continue;
+            watcher.add(dep);
+            watchedDeps.add(dep);
+        }
+        for (const dep of [...watchedDeps]) {
+            if (outside.has(dep))
+                continue;
+            watcher.unwatch(dep);
+            watchedDeps.delete(dep);
+        }
+    };
+    syncOutsideDeps();
     const queue = new Map();
     let timer = null;
+    // a source file is gone (deleted, or no longer analysable such as one that grew past the size limit)
+    const dropSource = async (abs) => {
+        sourceFiles.delete(abs);
+        skippedNow.delete(abs);
+        for (const virtualPath of plugins.getVirtualPathsForSource(abs)) {
+            trackedFiles.delete(virtualPath);
+            await engine.removeFile((0, getVirtualFile_1.getVirtualFile)(virtualPath), config);
+        }
+    };
     const run = async () => {
         const batch = [...queue.keys()];
         queue.clear();
+        if (batch.length === 0)
+            return;
+        const before = signature();
+        let touchedSource = false;
+        const skippedThisRun = [];
+        const ignoredThisRun = [];
+        // imported files outside `include` that changed, appeared or vanished: one rebuild for all of them
+        const external = batch.filter((file) => !isSource(file));
+        if (external.length > 0) {
+            try {
+                await engine.refreshExternalFiles(external, config);
+            }
+            catch (err) {
+                console.error(chalk_1.default.red(`watch error: ${(0, skipped_1.errorMessage)(err)}`));
+            }
+        }
         for (const file of batch) {
+            if (!isSource(file))
+                continue;
+            touchedSource = true;
             try {
                 const raw = await promises_1.default.readFile(file, "utf-8");
+                if ((0, fileLimits_1.isOversized)(raw)) {
+                    // too big to analyse, like `sync`: not a failure, and its events are not kept
+                    await dropSource(file);
+                    ignoredThisRun.push({ file, reason: fileLimits_1.OVERSIZED_REASON });
+                    continue;
+                }
                 const virtualFiles = await plugins.preprocessFile({ fileName: file, content: raw });
+                sourceFiles.add(file);
+                skippedNow.delete(file);
                 for (const virtualFile of virtualFiles) {
                     const scanPath = normalize(virtualFile.fileName);
-                    const parsed = await (0, processFile_1.processFile)(scanPath, virtualFile.content);
-                    cache.set(scanPath, parsed);
                     trackedFiles.add(scanPath);
                     await engine.updateFile((0, getVirtualFile_1.getVirtualFile)(scanPath), virtualFile.content, config);
-                    const prevDeps = fileDeps.get(scanPath) ?? new Set();
-                    const nextDeps = new Set(parsed.dependencies
-                        .filter((dep) => dep.startsWith(".") || dep.startsWith("/"))
-                        .map((dep) => normalize(path_1.default.resolve(path_1.default.dirname(scanPath), dep))));
-                    for (const dep of nextDeps) {
-                        if (prevDeps.has(dep))
-                            continue;
-                        watcher.add(dep);
-                        watchedDeps.add(dep);
-                    }
-                    for (const dep of prevDeps) {
-                        if (nextDeps.has(dep))
-                            continue;
-                        watcher.unwatch(dep);
-                        watchedDeps.delete(dep);
-                    }
-                    fileDeps.set(scanPath, nextDeps);
                 }
             }
-            catch {
-                console.log(chalk_1.default.gray(`skip: ${file}`));
+            catch (err) {
+                if (isNotFound(err)) {
+                    // gone before it could be read (created and deleted within one debounce, or removed mid-run)
+                    await dropSource(file);
+                    continue;
+                }
+                const skip = (0, skipped_1.skippedFrom)(file, err);
+                skippedNow.set(file, skip);
+                skippedThisRun.push(skip);
             }
         }
-        await (0, scanResults_1.persistScanResults)(config, engine);
-        console.log(chalk_1.default.green(`Updated: ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
+        (0, skipped_1.reportSkipped)(skippedThisRun);
+        (0, skipped_1.reportIgnored)(ignoredThisRun);
+        syncOutsideDeps();
+        // a batch of imported-only files that changed nothing about the result is not worth a write or a log line
+        if (!touchedSource && signature() === before)
+            return;
+        await persist();
+        console.log(chalk_1.default.green(`Updated: ${(0, skipped_1.plural)(engine.getAllEvents().length, "event")}, ${(0, skipped_1.plural)(engine.getAllFunctionWrappers().length, "wrapper")}`));
+    };
+    // One run at a time: a timer firing while the previous run is still awaiting
+    // would otherwise interleave two runs over the same engine.
+    let chain = Promise.resolve();
+    const enqueue = (task) => {
+        chain = chain.then(task).catch((err) => {
+            console.error(chalk_1.default.red(`watch error: ${(0, skipped_1.errorMessage)(err)}`));
+        });
     };
     const schedule = (file) => {
         const abs = normalize(file);
+        if (!shouldHandle(abs))
+            return;
         queue.set(abs, true);
         if (timer)
             clearTimeout(timer);
-        timer = setTimeout(run, 200);
+        timer = setTimeout(() => enqueue(run), 200);
     };
     watcher
         .on("change", schedule)
         .on("add", schedule)
-        .on("unlink", async (file) => {
+        .on("unlink", (file) => {
         const abs = normalize(file);
-        sourceFiles.delete(abs);
-        const virtualPaths = plugins.getVirtualPathsForSource(abs);
-        for (const virtualPath of virtualPaths) {
-            trackedFiles.delete(virtualPath);
-            await engine.removeFile((0, getVirtualFile_1.getVirtualFile)(virtualPath), config);
+        if (filter.isExcluded(abs))
+            return;
+        // a file that failed to analyse is in no set but is still remembered as skipped
+        if (!sourceFiles.has(abs) && !trackedFiles.has(abs) && !skippedNow.has(abs)) {
+            // an imported-only file vanished: dependents resolve differently now
+            if (CODE_FILE.test(abs) && engine.hasProgramFile(abs)) {
+                queue.set(abs, true);
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => enqueue(run), 200);
+            }
+            return;
         }
-        await (0, scanResults_1.persistScanResults)(config, engine);
-        console.log(chalk_1.default.red(`Removed → ${engine.getAllEvents().length} events, ${engine.getAllFunctionWrappers().length} wrappers`));
+        enqueue(async () => {
+            await dropSource(abs);
+            await persist();
+            console.log(chalk_1.default.red(`Removed -> ${(0, skipped_1.plural)(engine.getAllEvents().length, "event")}, ${(0, skipped_1.plural)(engine.getAllFunctionWrappers().length, "wrapper")}`));
+        });
     });
     process.on("SIGINT", async () => {
         await watcher.close();
         process.exit(0);
     });
+    return {
+        close: async () => {
+            if (timer)
+                clearTimeout(timer);
+            await watcher.close();
+            await chain;
+        },
+    };
 }

package/dist/compiler/compilerContext.js

@@ -11,10 +11,20 @@ const documentRegistry_1 = require("./documentRegistry");
 class CompilerContext {
     rootDir;
     registry = new documentRegistry_1.DocumentRegistry();
+    // Parsed files survive a program rebuild: a flush changes a handful of files,
+    // and parsing every other file (and the default lib .d.ts files) again was
+    // most of the rebuild cost. Reusing a SourceFile object across programs is
+    // what the TypeScript language service does too.
+    sourceFileCache = new Map();
     compilerOptions;
     host;
-    program = typescript_1.default.createProgram([], {});
+    // Built on first use (or by flushUpdates): the engine stages every file of a
+    // scan and flushes once, so an eager build in the constructor was thrown away.
+    programInstance;
     rootNames = new Set();
+    // Only set while withResolutionCache() runs: it memoises fileExists results,
+    // so it must never outlive one batch of resolutions against one program.
+    activeResolutionCache;
     constructor(rootDir) {
         this.rootDir = rootDir;
         const localTsconfig = path_1.default.join(rootDir, "tsconfig.json");
@@ -52,7 +62,6 @@ class CompilerContext {
         this.compilerOptions = compilerOptions;
         this.host = typescript_1.default.createCompilerHost(this.compilerOptions, true);
         this.patchCompilerHost();
-        this.rebuildProgram();
     }
     normalize(fileName) {
         return this.registry.normalize(fileName);
@@ -75,7 +84,17 @@ class CompilerContext {
         if (!snapshot) {
             return undefined;
         }
-        const sourceFile = typescript_1.default.createSourceFile(normalized, snapshot.getText(0, snapshot.getLength()), languageVersion, true, this.getScriptKind(normalized));
+        const content = snapshot.getText(0, snapshot.getLength());
+        const scriptKind = this.getScriptKind(normalized);
+        const cached = this.sourceFileCache.get(normalized);
+        if (cached &&
+            cached.content === content &&
+            cached.languageVersion === languageVersion &&
+            cached.scriptKind === scriptKind) {
+            return this.attachVersion(cached.sourceFile, normalized);
+        }
+        const sourceFile = typescript_1.default.createSourceFile(normalized, content, languageVersion, true, scriptKind);
+        this.sourceFileCache.set(normalized, { content, languageVersion, scriptKind, sourceFile });
         return this.attachVersion(sourceFile, normalized);
     }
     patchCompilerHost() {
@@ -127,7 +146,30 @@ class CompilerContext {
         return typescript_1.default.ScriptKind.Unknown;
     }
     rebuildProgram() {
-        this.program = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+        this.programInstance = typescript_1.default.createProgram([...this.rootNames], this.compilerOptions, this.host);
+    }
+    get program() {
+        if (!this.programInstance) {
+            this.rebuildProgram();
+        }
+        return this.programInstance;
+    }
+    /**
+     * Run `fn` with one shared module resolution cache, so resolving the imports
+     * of many files in a row (import graph after a flush) does not repeat the
+     * same directory lookups. The cache is dropped when `fn` returns.
+     */
+    withResolutionCache(fn) {
+        if (this.activeResolutionCache) {
+            return fn();
+        }
+        this.activeResolutionCache = typescript_1.default.createModuleResolutionCache(this.rootDir, (fileName) => this.normalize(fileName), this.compilerOptions);
+        try {
+            return fn();
+        }
+        finally {
+            this.activeResolutionCache = undefined;
+        }
     }
     /** Register file content without rebuilding the TS program (batch via {@link flushUpdates}). */
     stageFile(fileName, content) {
@@ -147,9 +189,65 @@ class CompilerContext {
     removeFile(fileName) {
         const normalized = this.normalize(fileName);
         this.registry.remove(normalized);
+        this.sourceFileCache.delete(normalized);
         this.rootNames.delete(normalized);
         this.rebuildProgram();
     }
+    /**
+     * Re-reads files that are in the program only because something imports them
+     * (they are not scanned sources): the disk content replaces whatever the
+     * registry cached and the program is rebuilt ONCE for the whole batch. A file
+     * that no longer exists is dropped. Returns the files whose content really
+     * changed (normalized); none of them ever becomes a root.
+     */
+    refreshFromDisk(fileNames) {
+        const changed = [];
+        for (const fileName of fileNames) {
+            const normalized = this.normalize(fileName);
+            const before = this.registry.getContent(normalized);
+            let content;
+            try {
+                content = fs_1.default.readFileSync(normalized, "utf8");
+            }
+            catch {
+                content = undefined;
+            }
+            if (before === content)
+                continue;
+            if (content === undefined) {
+                this.registry.remove(normalized);
+                this.sourceFileCache.delete(normalized);
+            }
+            else {
+                this.registry.update(normalized, content);
+            }
+            changed.push(normalized);
+        }
+        if (changed.length === 0) {
+            return changed;
+        }
+        this.rebuildProgram();
+        // a file nothing imports must not linger in the registry
+        for (const normalized of changed) {
+            if (this.registry.has(normalized) && !this.programInstance.getSourceFile(normalized)) {
+                this.registry.remove(normalized);
+                this.sourceFileCache.delete(normalized);
+            }
+        }
+        return changed;
+    }
+    /** True when the file is part of the current program (scanned or only imported). */
+    hasFile(fileName) {
+        return this.program.getSourceFile(this.normalize(fileName)) !== undefined;
+    }
+    /** Project files of the program (no TypeScript libs, no node_modules), declaration files included. */
+    getProjectFileNames() {
+        const program = this.program;
+        return program
+            .getSourceFiles()
+            .filter((sf) => !program.isSourceFileDefaultLibrary(sf) && !program.isSourceFileFromExternalLibrary(sf))
+            .map((sf) => sf.fileName);
+    }
     getProgram() {
         return this.program;
     }
@@ -173,7 +271,7 @@ class CompilerContext {
         ];
     }
     resolveModule(moduleName, fromFile) {
-        const resolved = typescript_1.default.resolveModuleName(moduleName, this.normalize(fromFile), this.compilerOptions, this.host);
+        const resolved = typescript_1.default.resolveModuleName(moduleName, this.normalize(fromFile), this.compilerOptions, this.host, this.activeResolutionCache);
         return resolved.resolvedModule?.resolvedFileName;
     }
     getResolvedModules(fileName) {

package/dist/compiler/documentRegistry.js

@@ -9,8 +9,22 @@ const path_1 = __importDefault(require("path"));
 const typescript_1 = __importDefault(require("typescript"));
 class DocumentRegistry {
     documents = new Map();
+    // path.resolve + regex ran thousands of times per scan on the same inputs;
+    // keyed on cwd because relative inputs resolve against it
+    normalizedCache = new Map();
+    normalizedCwd = "";
     normalize(fileName) {
-        return path_1.default.resolve(fileName).replace(/\\/g, "/");
+        const cwd = process.cwd();
+        if (cwd !== this.normalizedCwd) {
+            this.normalizedCache.clear();
+            this.normalizedCwd = cwd;
+        }
+        let normalized = this.normalizedCache.get(fileName);
+        if (normalized === undefined) {
+            normalized = path_1.default.resolve(fileName).replace(/\\/g, "/");
+            this.normalizedCache.set(fileName, normalized);
+        }
+        return normalized;
     }
     has(fileName) {
         return this.documents.has(this.normalize(fileName));

package/dist/compiler/importGraph.js

@@ -7,6 +7,13 @@ class ImportGraph {
     imports = new Map();
     // import -> importers
     reverse = new Map();
+    hasFile(file) {
+        return this.imports.has(file);
+    }
+    getFiles() {
+        return [...this.imports.keys()];
+    }
+    /** Returns true when the set of files this file imports changed. */
     updateFile(file, nextImports) {
         const previous = this.imports.get(file) ?? new Set();
         const next = new Set(nextImports);
@@ -36,6 +43,7 @@ class ImportGraph {
             importers.add(file);
         }
         this.imports.set(file, next);
+        return previous.size !== next.size || [...next].some((imported) => !previous.has(imported));
     }
     removeFile(file) {
         const imports = this.imports.get(file);

package/dist/config/config.js

@@ -6,6 +6,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LOCAL_CONFIG_NAME = exports.CONFIG_NAME = void 0;
 exports.normalizeConfig = normalizeConfig;
 exports.loadConfig = loadConfig;
+exports.describeConfigProblem = describeConfigProblem;
+exports.requireConfig = requireConfig;
 exports.saveConfig = saveConfig;
 exports.resolveApiKey = resolveApiKey;
 exports.saveLocalApiKey = saveLocalApiKey;
@@ -42,7 +44,9 @@ function normalizeConfig(config) {
         apiKey: config.apiKey ?? "",
         endpoint: config.endpoint ?? "",
         events: [...(config.events ?? [])].sort(),
-        functionWrappers: uniqueWrappers.sort((a, b) => a.name.localeCompare(b.name)),
+        // plain comparison, not localeCompare: the order in the committed file must
+        // not depend on the machine's ICU locale
+        functionWrappers: uniqueWrappers.sort((a, b) => (a.name < b.name ? -1 : 1)),
         plugins: [...(config.plugins ?? [])],
         ...(sinks.length > 0 ? { sinks } : {}),
         sync: {
@@ -64,9 +68,48 @@ async function loadConfig() {
         return null;
     }
 }
+/**
+ * Says why `loadConfig` returned null, for the CLI's error message: a missing
+ * file and a malformed one are different problems.
+ */
+async function describeConfigProblem() {
+    const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
+    if (!(await fs_extra_1.default.pathExists(configPath)))
+        return `${exports.CONFIG_NAME} not found`;
+    try {
+        await fs_extra_1.default.readJSON(configPath);
+        return `${exports.CONFIG_NAME} could not be read`;
+    }
+    catch (err) {
+        // readJSON only rejects with an Error (ENOENT was ruled out above, the rest is a parse error)
+        return `${exports.CONFIG_NAME} is not valid JSON: ${err.message}`;
+    }
+}
+/**
+ * Loads the config for a command that cannot run without it. On failure it
+ * prints the reason and sets a non-zero exit code, and returns null, so every
+ * command ends the same way when there is no usable config.
+ */
+async function requireConfig() {
+    const config = await loadConfig();
+    if (config)
+        return config;
+    console.error(await describeConfigProblem());
+    process.exitCode = 1;
+    return null;
+}
+/** Writes eventra.json only when its content actually changed (watch mode re-saves often). */
 async function saveConfig(config) {
     const configPath = path_1.default.join(process.cwd(), exports.CONFIG_NAME);
-    await fs_extra_1.default.writeJSON(configPath, normalizeConfig(config), { spaces: 2 });
+    const next = `${JSON.stringify(normalizeConfig(config), null, 2)}\n`;
+    try {
+        if ((await fs_extra_1.default.readFile(configPath, "utf8")) === next)
+            return;
+    }
+    catch {
+        // missing or unreadable: write it
+    }
+    await fs_extra_1.default.writeFile(configPath, next);
 }
 async function readLocalSecrets() {
     const localPath = path_1.default.join(process.cwd(), exports.LOCAL_CONFIG_NAME);