@eventra_dev/eventra-cli 2.0.10 → 2.2.0

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;
@@ -21,6 +23,11 @@ exports.CONFIG_NAME = "eventra.json";
 exports.LOCAL_CONFIG_NAME = "eventra.local.json";
 const DEFAULT_INCLUDE = ["**/*.{ts,tsx,js,jsx}"];
 const DEFAULT_EXCLUDE = ["node_modules", "dist", ".next", ".git"];
+function normalizeSinks(sinks) {
+    if (!Array.isArray(sinks))
+        return [];
+    return sinks.filter((s) => typeof s === "object" && s !== null && !Array.isArray(s));
+}
 function normalizeConfig(config) {
     const functionWrappers = (config.functionWrappers ?? [])
         .filter((w) => w?.name)
@@ -32,12 +39,16 @@ function normalizeConfig(config) {
         seen.add(w.name);
         return true;
     });
+    const sinks = normalizeSinks(config.sinks);
     return {
         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: {
             include: config.sync?.include ?? DEFAULT_INCLUDE,
             exclude: config.sync?.exclude ?? DEFAULT_EXCLUDE,
@@ -57,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);

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;
+}