@eventra_dev/eventra-cli 2.1.0 → 2.3.0

package/dist/core/skipped.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanSkipReason = cleanSkipReason;
+exports.errorMessage = errorMessage;
+exports.skippedFrom = skippedFrom;
+exports.formatSkipped = formatSkipped;
+exports.reportSkipped = reportSkipped;
+exports.formatIgnored = formatIgnored;
+exports.reportIgnored = reportIgnored;
+exports.plural = plural;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+/**
+ * A skipped file's error is wrapped once by the CLI, once by the plugin
+ * adapter and once by the plugin itself, each repeating the path. Keep only the
+ * innermost message.
+ */
+function cleanSkipReason(file, message) {
+    let text = message.split(file).join("").trim();
+    text = text.replace(/^Plugin "[^"]*" failed to transform\s*:\s*/, "");
+    text = text.replace(/^Failed to parse [A-Za-z][A-Za-z ]*?\s*:\s*/, "");
+    return text.replace(/\s+/g, " ").trim() || "unknown error";
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+function skippedFrom(file, err) {
+    return { file, reason: cleanSkipReason(file, errorMessage(err)) };
+}
+function formatSkipped(skipped, cwd) {
+    if (skipped.length === 0)
+        return [];
+    const lines = [
+        `Skipped ${skipped.length} file${skipped.length === 1 ? "" : "s"} that could not be analysed:`,
+    ];
+    for (const { file, reason } of skipped) {
+        lines.push(`  ${path_1.default.relative(cwd, file).replace(/\\/g, "/")}: ${reason}`);
+    }
+    return lines;
+}
+/** Prints one summary block (stderr) for everything skipped in a scan. */
+function reportSkipped(skipped, cwd = process.cwd()) {
+    const lines = formatSkipped(skipped, cwd);
+    if (lines.length === 0)
+        return;
+    console.error(chalk_1.default.yellow(lines.join("\n")));
+    console.error(chalk_1.default.gray("Events from these files are not in this scan; previously known events were kept. Use --strict to fail on skipped files."));
+}
+/**
+ * Files that were deliberately not analysed (for example generated bundles
+ * over the size limit). Unlike skipped files they are not failures: their
+ * absence neither keeps known events nor makes a catalog snapshot incomplete.
+ */
+function formatIgnored(ignored, cwd) {
+    if (ignored.length === 0)
+        return [];
+    const lines = [
+        `Ignored ${ignored.length} file${ignored.length === 1 ? "" : "s"} (not analysed):`,
+    ];
+    for (const { file, reason } of ignored) {
+        lines.push(`  ${path_1.default.relative(cwd, file).replace(/\\/g, "/")}: ${reason}`);
+    }
+    return lines;
+}
+/** Prints one note (stderr) for everything ignored in a scan. */
+function reportIgnored(ignored, cwd = process.cwd()) {
+    const lines = formatIgnored(ignored, cwd);
+    if (lines.length === 0)
+        return;
+    console.error(chalk_1.default.gray(lines.join("\n")));
+}
+function plural(count, singular, pluralForm = `${singular}s`) {
+    return `${count} ${count === 1 ? singular : pluralForm}`;
+}

package/dist/index.js

@@ -39,42 +39,53 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const package_json_1 = __importDefault(require("../package.json"));
-const program = new commander_1.Command();
-program
-    .name("eventra")
-    .description("Eventra CLI")
-    .version(package_json_1.default.version);
-program
-    .command("init")
-    .action(async () => {
-    const { init } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
-    await init();
+const respawn_1 = require("./respawn");
+// a large repository can need more memory than Node's default: start again with enough
+(0, respawn_1.respawnWithMoreHeap)().then((respawned) => {
+    if (!respawned)
+        run();
 });
-program
-    .command("sync")
-    .action(async () => {
-    const { sync } = await Promise.resolve().then(() => __importStar(require("./cli/sync")));
-    await sync();
-});
-program
-    .command("check")
-    .option("--fix", "auto fix issues")
-    .action(async (opts) => {
-    const { check } = await Promise.resolve().then(() => __importStar(require("./cli/check")));
-    await check({ fix: opts.fix });
-});
-program
-    .command("watch")
-    .description("Watch files and detect events in real-time")
-    .action(async () => {
-    const { watch } = await Promise.resolve().then(() => __importStar(require("./cli/watch")));
-    await watch();
-});
-program
-    .command("send")
-    .option("--trust-endpoint", "approve the current eventra.json endpoint for local use")
-    .action(async (opts) => {
-    const { send } = await Promise.resolve().then(() => __importStar(require("./cli/send")));
-    await send({ trustEndpoint: opts.trustEndpoint });
-});
-program.parse();
+function run() {
+    const program = new commander_1.Command();
+    program
+        .name("eventra")
+        .description("Eventra CLI")
+        .version(package_json_1.default.version);
+    program
+        .command("init")
+        .option("-y, --yes", "do not prompt: accept defaults and keep an existing eventra.json")
+        .action(async (opts) => {
+        const { init } = await Promise.resolve().then(() => __importStar(require("./cli/init")));
+        await init({ yes: opts.yes });
+    });
+    program
+        .command("sync")
+        .option("--strict", "exit with a non-zero code if any file could not be analysed")
+        .action(async (opts) => {
+        const { sync } = await Promise.resolve().then(() => __importStar(require("./cli/sync")));
+        await sync({ strict: opts.strict });
+    });
+    program
+        .command("check")
+        .option("--fix", "auto fix issues")
+        .option("--strict", "exit with a non-zero code if any file could not be analysed")
+        .action(async (opts) => {
+        const { check } = await Promise.resolve().then(() => __importStar(require("./cli/check")));
+        await check({ fix: opts.fix, strict: opts.strict });
+    });
+    program
+        .command("watch")
+        .description("Watch files and detect events in real-time")
+        .action(async () => {
+        const { watch } = await Promise.resolve().then(() => __importStar(require("./cli/watch")));
+        await watch();
+    });
+    program
+        .command("send")
+        .option("--trust-endpoint", "approve the current eventra.json endpoint for local use")
+        .action(async (opts) => {
+        const { send } = await Promise.resolve().then(() => __importStar(require("./cli/send")));
+        await send({ trustEndpoint: opts.trustEndpoint });
+    });
+    program.parse();
+}

package/dist/plugin/builtins/configuredSinks.js

@@ -82,20 +82,6 @@ function moduleMatches(specifier, modules) {
     return modules.some((m) => specifier === m || specifier.startsWith(`${m}/`));
 }
 const MAX_ALIAS_HOPS = 6;
-/** Identifiers naming the types in a type annotation: `PostHog`, `PostHog | null`, `ph.PostHog`. */
-function typeReferenceRoots(type) {
-    if (typescript_1.default.isParenthesizedTypeNode(type))
-        return typeReferenceRoots(type.type);
-    if (typescript_1.default.isUnionTypeNode(type) || typescript_1.default.isIntersectionTypeNode(type))
-        return type.types.flatMap(typeReferenceRoots);
-    if (typescript_1.default.isTypeReferenceNode(type)) {
-        let name = type.typeName;
-        while (typescript_1.default.isQualifiedName(name))
-            name = name.left;
-        return [name];
-    }
-    return [];
-}
 /**
  * The symbol an identifier refers to, keeping an import as the import binding itself. TS resolves an
  * import all the way to its target in some positions once something makes the module resolvable
@@ -109,6 +95,55 @@ function symbolAt(id, checker) {
         return symbol;
     return checker.getSymbolsInScope(id, typescript_1.default.SymbolFlags.Alias).find((alias) => alias.name === id.text) ?? symbol;
 }
+/** `import("m")`: the specifier of the call decides, no installed package needed. */
+function dynamicImportFrom(expression, modules) {
+    const specifier = typescript_1.default.isCallExpression(expression) && expression.expression.kind === typescript_1.default.SyntaxKind.ImportKeyword
+        ? expression.arguments[0]
+        : undefined;
+    return specifier !== undefined && typescript_1.default.isStringLiteralLike(specifier) && moduleMatches(specifier.text, modules);
+}
+const PROMISE_TYPES = new Set(["Promise", "PromiseLike"]);
+/**
+ * True when a type annotation names something from `modules`: `PostHog`, `PostHog | null`, `ph.PostHog`,
+ * `typeof import("posthog-js")`, `Promise<typeof import("posthog-js")>`, `typeof posthog`.
+ */
+function typeFromModules(type, checker, modules, hops) {
+    if (typescript_1.default.isParenthesizedTypeNode(type))
+        return typeFromModules(type.type, checker, modules, hops);
+    if (typescript_1.default.isUnionTypeNode(type) || typescript_1.default.isIntersectionTypeNode(type)) {
+        return type.types.some((member) => typeFromModules(member, checker, modules, hops));
+    }
+    if (typescript_1.default.isImportTypeNode(type)) {
+        return typescript_1.default.isLiteralTypeNode(type.argument) && typescript_1.default.isStringLiteral(type.argument.literal) && moduleMatches(type.argument.literal.text, modules);
+    }
+    const name = typescript_1.default.isTypeReferenceNode(type) ? type.typeName : typescript_1.default.isTypeQueryNode(type) ? type.exprName : undefined;
+    if (name === undefined)
+        return false;
+    let root = name;
+    while (typescript_1.default.isQualifiedName(root))
+        root = root.left;
+    return (symbolFromModules(symbolAt(root, checker), checker, modules, hops + 1) ||
+        // a promise of the module (`Promise<typeof import("posthog-js")>`), not any generic that mentions it
+        (typescript_1.default.isTypeReferenceNode(type) &&
+            typescript_1.default.isIdentifier(type.typeName) &&
+            PROMISE_TYPES.has(type.typeName.text) &&
+            (type.typeArguments ?? []).some((argument) => typeFromModules(argument, checker, modules, hops))));
+}
+/** `return expr` statements of a function body, not looking into functions nested in it. */
+function returnedExpressions(body) {
+    if (!typescript_1.default.isBlock(body))
+        return [body];
+    const found = [];
+    const visit = (node) => {
+        if (typescript_1.default.isFunctionLike(node))
+            return;
+        if (typescript_1.default.isReturnStatement(node) && node.expression)
+            found.push(node.expression);
+        typescript_1.default.forEachChild(node, visit);
+    };
+    typescript_1.default.forEachChild(body, visit);
+    return found;
+}
 /** The symbol `name` exported by the module a specifier points at, when TS can resolve that module. */
 function resolveExport(specifier, name, checker) {
     const moduleSymbol = checker.getSymbolAtLocation(specifier);
@@ -123,6 +158,8 @@ function expressionFromModules(expression, checker, modules, hops) {
     let expr = (0, utils_1.unwrapExpression)(expression);
     if (typescript_1.default.isAwaitExpression(expr))
         expr = (0, utils_1.unwrapExpression)(expr.expression);
+    if (dynamicImportFrom(expr, modules))
+        return true;
     if (typescript_1.default.isCallExpression(expr) || typescript_1.default.isNewExpression(expr))
         expr = (0, utils_1.unwrapExpression)(expr.expression);
     const fromName = (name) => typescript_1.default.isIdentifier(name) && symbolFromModules(symbolAt(name, checker), checker, modules, hops);
@@ -133,7 +170,10 @@ function expressionFromModules(expression, checker, modules, hops) {
     let root = expr;
     while (typescript_1.default.isPropertyAccessExpression(root))
         root = (0, utils_1.unwrapExpression)(root.expression);
-    return fromName(expr.name) || fromName(root);
+    // `(await import("posthog-js")).default`
+    if (typescript_1.default.isAwaitExpression(root))
+        root = (0, utils_1.unwrapExpression)(root.expression);
+    return fromName(expr.name) || fromName(root) || dynamicImportFrom(root, modules);
 }
 function declarationFromModules(decl, checker, modules, hops) {
     if (typescript_1.default.isImportSpecifier(decl) || typescript_1.default.isImportClause(decl) || typescript_1.default.isNamespaceImport(decl)) {
@@ -162,15 +202,42 @@ function declarationFromModules(decl, checker, modules, hops) {
     if (typescript_1.default.isExportAssignment(decl)) {
         return expressionFromModules(decl.expression, checker, modules, hops + 1);
     }
+    // function useAnalytics() { return usePostHog() } / const load = () => import("posthog-js"): a function
+    // gives back what it returns (or what its return annotation names)
+    const fn = typescript_1.default.isFunctionDeclaration(decl) || typescript_1.default.isMethodDeclaration(decl)
+        ? decl
+        : (typescript_1.default.isVariableDeclaration(decl) || typescript_1.default.isPropertyDeclaration(decl)) &&
+            decl.initializer &&
+            (typescript_1.default.isArrowFunction(decl.initializer) || typescript_1.default.isFunctionExpression(decl.initializer))
+            ? decl.initializer
+            : undefined;
+    if (fn) {
+        if (fn.type && typeFromModules(fn.type, checker, modules, hops))
+            return true;
+        if (fn.body && returnedExpressions(fn.body).some((returned) => expressionFromModules(returned, checker, modules, hops + 1))) {
+            return true;
+        }
+    }
     // const { posthog } = usePostHog(): the binding's own declaration is the enclosing variable.
     const owner = typescript_1.default.isBindingElement(decl) ? decl.parent.parent : decl;
+    // promise.then(({ default: posthog }) => ...) / promise.then((mod) => ...): the parameter holds what the promise resolves to
+    if (typescript_1.default.isParameter(owner)) {
+        const callback = owner.parent;
+        const call = callback.parent;
+        if ((typescript_1.default.isArrowFunction(callback) || typescript_1.default.isFunctionExpression(callback)) &&
+            typescript_1.default.isCallExpression(call) &&
+            call.arguments[0] === callback &&
+            typescript_1.default.isPropertyAccessExpression(call.expression) &&
+            call.expression.name.text === "then") {
+            return expressionFromModules(call.expression.expression, checker, modules, hops + 1);
+        }
+    }
     // Variables, properties, parameters, functions (return type) and type aliases all keep their
     // annotation in `type`; variables, properties and parameters keep a default/initial value in
     // `initializer`. Anything else (classes, interfaces, ...) simply has neither.
     const { type, initializer } = owner;
     // let client: PostHog | null / private client: PostHog / (client: PostHog) => ... / type Client = PostHog
-    if (type &&
-        typeReferenceRoots(type).some((id) => symbolFromModules(symbolAt(id, checker), checker, modules, hops + 1))) {
+    if (type && typeFromModules(type, checker, modules, hops)) {
         return true;
     }
     // const ph = usePostHog() / new PostHog(k) / client = new PostHog(k) / const useTrack = usePostHog

package/dist/plugin/builtins/consoleDynamicEventReporter.js

@@ -5,16 +5,35 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerConsoleDynamicEventReporterPlugin = registerConsoleDynamicEventReporterPlugin;
 const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+// paths are printed relative to where the command runs, with forward slashes
+function displayPath(fileName) {
+    const relative = path_1.default.relative(process.cwd(), fileName);
+    const outside = relative === ".." || relative.startsWith(`..${path_1.default.sep}`) || relative.startsWith("../");
+    const shown = relative && !outside && !path_1.default.isAbsolute(relative) ? relative : fileName;
+    return shown.replace(/\\/g, "/");
+}
 const consoleDynamicEventReporter = {
     name: "console",
-    report({ occurrences }) {
+    report({ occurrences: all }) {
+        // the copy of a component class inside an Angular template module repeats a call the class file already reports
+        const occurrences = all.filter((occ) => !occ.inGeneratedCode);
         if (occurrences.length === 0) {
             return;
         }
         console.log(chalk_1.default.blue("\nDynamic event names:"));
         for (const occ of occurrences) {
             const values = occ.resolvedValues.length > 0 ? ` (resolved: ${occ.resolvedValues.join(", ")})` : "";
-            console.log(chalk_1.default.yellow(`~ ${occ.fileName}:${occ.line} ${occ.calleeText}(...)${values}`));
+            const file = displayPath(occ.fileName);
+            if (occ.inTemplate) {
+                console.log(chalk_1.default.yellow(`~ template of ${file}: event="${occ.eventExpression ?? ""}"${values}`));
+            }
+            else if (occ.inTemplateCode) {
+                console.log(chalk_1.default.yellow(`~ template of ${file}: ${occ.calleeText}(...)${values}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow(`~ ${file}:${occ.line} ${occ.calleeText}(...)${values}`));
+            }
         }
     },
 };

package/dist/plugin/loadPlugins.js

@@ -32,10 +32,15 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isTrustedPluginSpecifier = isTrustedPluginSpecifier;
 exports.createBuiltinPluginRegistry = createBuiltinPluginRegistry;
 exports.createPluginRegistry = createPluginRegistry;
+const module_1 = require("module");
+const path_1 = __importDefault(require("path"));
 const external_1 = require("./adapters/external");
 const configuredSinks_1 = require("./builtins/configuredSinks");
 const eventra_sdk_1 = require("./builtins/eventra-sdk");
@@ -69,6 +74,19 @@ function pluginLoadHint(spec) {
     }
     return "";
 }
+/**
+ * Plugins are installed in the user's project, not next to the CLI (a global
+ * install, npx or a pnpm layout would not find them from here), so resolve from
+ * the project first and fall back to normal resolution relative to the CLI.
+ */
+function resolveFromProject(spec) {
+    try {
+        return (0, module_1.createRequire)(path_1.default.join(process.cwd(), "package.json")).resolve(spec);
+    }
+    catch {
+        return spec;
+    }
+}
 async function loadExternalPlugin(registry, spec) {
     const trimmed = spec.trim();
     // Defensive-only: the sole caller (createPluginRegistry) already does
@@ -80,7 +98,7 @@ async function loadExternalPlugin(registry, spec) {
         return;
     let mod;
     try {
-        mod = await Promise.resolve(`${trimmed}`).then(s => __importStar(require(s)));
+        mod = await Promise.resolve(`${resolveFromProject(trimmed)}`).then(s => __importStar(require(s)));
     }
     catch (err) {
         // Node's dynamic import() only ever rejects with an Error (module
@@ -114,7 +132,7 @@ async function createPluginRegistry(config) {
         if (!trimmed)
             continue;
         if (!isTrustedPluginSpecifier(trimmed)) {
-            console.warn(`Eventra: skipping plugin "${trimmed}" — only official @eventra_dev/cli-plugin-* packages can be loaded.${pluginLoadHint(trimmed)}`);
+            console.warn(`Eventra: skipping plugin "${trimmed}" - only official @eventra_dev/cli-plugin-* packages can be loaded.${pluginLoadHint(trimmed)}`);
             continue;
         }
         await loadExternalPlugin(registry, trimmed);

package/dist/plugin/registry.js

@@ -5,6 +5,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PluginRegistry = void 0;
 const path_1 = __importDefault(require("path"));
+// the synthetic callee each framework plugin uses for a template `event=...`
+const TEMPLATE_CALLEE = /^__eventra_[a-z]+_template_event__$/;
+// A plugin starts the code it generates from a template with this comment line, so a call found
+// below it is not on a line the user wrote.
+const TEMPLATE_REGION_START = /^\s*\/\/ --- [a-z]+ template \(auto-generated\) ---$/;
+// optional: a module that carries more after the generated code (an Angular component class) ends it
+const TEMPLATE_REGION_END = /^\s*\/\/ --- end template ---$/;
+// 1-based lines of the generated template region in a virtual module, or undefined when it has none
+function templateRegionOf(content) {
+    const lines = content.split("\n");
+    const start = lines.findIndex((line) => TEMPLATE_REGION_START.test(line));
+    if (start === -1)
+        return undefined;
+    const end = lines.findIndex((line, index) => index > start && TEMPLATE_REGION_END.test(line));
+    return { from: start + 1, to: end === -1 ? Infinity : end + 1 };
+}
+// `__eventra_x_template_event__(expr)` (callText may be cut with an ellipsis)
+function templateExpression(occurrence) {
+    const open = occurrence.callText.indexOf("(");
+    let expression = open === -1 ? occurrence.callText : occurrence.callText.slice(open + 1);
+    expression = expression.endsWith(")") ? expression.slice(0, -1) : expression;
+    // Angular qualifies a bare name with `this.`; the template never writes it
+    return occurrence.calleeText.includes("_angular_") ? expression.replace(/^this\./, "") : expression;
+}
 class PluginRegistry {
     preprocessors = [];
     sinkDetectors = [];
@@ -12,6 +36,7 @@ class PluginRegistry {
     dynamicEventReporters = [];
     includePatterns = [];
     sourceToVirtuals = new Map();
+    templateRegions = new Map();
     registerFilePreprocessor(preprocessor) {
         if (this.preprocessors.some((p) => p.name === preprocessor.name)) {
             throw new Error(`File preprocessor already registered: ${preprocessor.name}`);
@@ -75,10 +100,23 @@ class PluginRegistry {
             }
             const files = await preprocessor.process(input);
             if (files.length > 0) {
+                // virtual files this source produced before and no longer does: their regions are not valid for anything else
+                for (const stale of this.sourceToVirtuals.get(sourceKey) ?? [])
+                    this.templateRegions.delete(stale);
+                for (const file of files) {
+                    const key = this.normalizePath(file.fileName);
+                    const region = templateRegionOf(file.content);
+                    if (region === undefined)
+                        this.templateRegions.delete(key);
+                    else
+                        this.templateRegions.set(key, region);
+                }
                 this.sourceToVirtuals.set(sourceKey, files.map((file) => this.normalizePath(file.fileName)));
                 return files;
             }
         }
+        for (const stale of this.sourceToVirtuals.get(sourceKey) ?? [])
+            this.templateRegions.delete(stale);
         this.sourceToVirtuals.delete(sourceKey);
         return [{ fileName: input.fileName, content: input.content }];
     }
@@ -101,10 +139,54 @@ class PluginRegistry {
         return null;
     }
     async runDynamicEventReporters(occurrences) {
+        const attributed = this.attributeToSources(occurrences);
         for (const reporter of this.dynamicEventReporters) {
-            await reporter.report({ occurrences });
+            await reporter.report({ occurrences: attributed });
         }
     }
+    /**
+     * Occurrences are found in virtual modules (`App.vue.ts`). Point them back
+     * at the file the user wrote, and flag the ones that come from generated
+     * code so reporters do not print a line number that exists nowhere.
+     */
+    attributeToSources(occurrences) {
+        if (this.sourceToVirtuals.size === 0) {
+            return occurrences;
+        }
+        const virtualToSource = new Map();
+        for (const [source, virtuals] of this.sourceToVirtuals) {
+            for (const virtual of virtuals) {
+                if (virtual !== source) {
+                    virtualToSource.set(virtual, source);
+                }
+            }
+        }
+        return occurrences.map((occurrence) => {
+            const source = virtualToSource.get(this.normalizePath(occurrence.fileName));
+            if (!source) {
+                return occurrence;
+            }
+            const template = TEMPLATE_CALLEE.test(occurrence.calleeText);
+            if (template) {
+                return {
+                    ...occurrence,
+                    fileName: source,
+                    inTemplate: true,
+                    eventExpression: templateExpression(occurrence),
+                };
+            }
+            // ordinary code the plugin copied out of the template: its line is in the generated text
+            const region = this.templateRegions.get(this.normalizePath(occurrence.fileName));
+            if (region !== undefined && occurrence.line >= region.from && occurrence.line <= region.to) {
+                return { ...occurrence, fileName: source, inTemplateCode: true };
+            }
+            // an Angular template module embeds the component class: lines there
+            // are generated, the real call is also reported from the class file
+            return source.toLowerCase().endsWith(".html")
+                ? { ...occurrence, fileName: source, inGeneratedCode: true }
+                : { ...occurrence, fileName: source };
+        });
+    }
     normalizePath(fileName) {
         return path_1.default.resolve(fileName).replace(/\\/g, "/");
     }

package/dist/respawn.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultRespawnDeps = exports.SCANNING_COMMANDS = exports.RESPAWN_ENV = void 0;
+exports.wantedHeapMb = wantedHeapMb;
+exports.usableMemory = usableMemory;
+exports.respawnWithMoreHeap = respawnWithMoreHeap;
+const child_process_1 = require("child_process");
+const os_1 = __importDefault(require("os"));
+const v8_1 = __importDefault(require("v8"));
+/** Set on the child, so a process started with more memory never starts another one. */
+exports.RESPAWN_ENV = "EVENTRA_HEAP_RESPAWNED";
+/** The commands that read the whole project; the rest (`init`, `--version`, `--help`) stay in one process. */
+exports.SCANNING_COMMANDS = new Set(["sync", "check", "watch", "send"]);
+const MIB = 1024 * 1024;
+// a project of tens of thousands of files needs a few GB while its program is built; more than
+// this is never useful, and half the machine's memory is what can be taken without hurting it
+const MAX_HEAP_MB = 8192;
+const SHARE_OF_MEMORY = 0.5;
+/** Signals a parent passes on, so stopping it stops the child too instead of leaving it running. */
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+/**
+ * The old-space limit (MB) worth starting with, or `undefined` to carry on as is: Node's default
+ * limit is a fraction of the memory and can be well below what a large monorepo needs.
+ */
+function wantedHeapMb(availableMemoryBytes, currentLimitBytes) {
+    const wanted = Math.min(MAX_HEAP_MB, Math.floor((availableMemoryBytes * SHARE_OF_MEMORY) / MIB));
+    // not worth a second process for a small difference
+    return wanted > (currentLimitBytes / MIB) * 1.25 ? wanted : undefined;
+}
+/**
+ * Memory this process can use: the smaller of the machine's and the container's limit (cgroups) when it has
+ * one. `constrained` is 0 when nothing limits the process, and undefined on a Node that does not report it.
+ */
+function usableMemory(total, constrained) {
+    return constrained !== undefined && constrained > 0 ? Math.min(total, constrained) : total;
+}
+function runChild(command, args, env) {
+    return new Promise((resolve) => {
+        const child = (0, child_process_1.spawn)(command, [...args], { stdio: "inherit", env });
+        const forwarders = FORWARDED_SIGNALS.map((signal) => {
+            const forward = () => child.kill(signal);
+            process.on(signal, forward);
+            return [signal, forward];
+        });
+        const done = (code) => {
+            for (const [signal, forward] of forwarders)
+                process.off(signal, forward);
+            resolve(code);
+        };
+        // a child that could not start at all (`error`) counts as a failed run, like one killed by a signal
+        child.on("error", () => done(1));
+        child.on("exit", (code) => done(code ?? 1));
+    });
+}
+const defaultRespawnDeps = () => ({
+    env: process.env,
+    execArgv: process.execArgv,
+    argv: process.argv,
+    execPath: process.execPath,
+    availableMemoryBytes: usableMemory(os_1.default.totalmem(), os_1.default.constrainedMemory?.()),
+    heapLimitBytes: v8_1.default.getHeapStatistics().heap_size_limit,
+    run: runChild,
+    exit: (code) => process.exit(code),
+});
+exports.defaultRespawnDeps = defaultRespawnDeps;
+/**
+ * Runs a scanning command again in a child with a larger heap when this process would start with too
+ * little, and exits with the child's status. Resolves `true` when it did, so the caller stops there. An
+ * explicit `--max-old-space-size` (in NODE_OPTIONS or the command line) is the user's choice and is left alone.
+ */
+async function respawnWithMoreHeap(deps = (0, exports.defaultRespawnDeps)()) {
+    if (deps.env[exports.RESPAWN_ENV])
+        return false;
+    // a second process costs startup time, so only a command that scans a project is worth it
+    if (!exports.SCANNING_COMMANDS.has(deps.argv[2] ?? ""))
+        return false;
+    const explicit = [deps.env.NODE_OPTIONS ?? "", ...deps.execArgv].some((part) => part.includes("max-old-space-size"));
+    if (explicit)
+        return false;
+    const heapMb = wantedHeapMb(deps.availableMemoryBytes, deps.heapLimitBytes);
+    if (heapMb === undefined)
+        return false;
+    const code = await deps.run(deps.execPath, [`--max-old-space-size=${heapMb}`, ...deps.execArgv, ...deps.argv.slice(1)], { ...deps.env, [exports.RESPAWN_ENV]: "1" });
+    deps.exit(code);
+    return true;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eventra_dev/eventra-cli",
-  "version": "2.1.0",
+  "version": "2.3.0",
   "description": "Static analytics event extraction CLI powered by the TypeScript compiler API",
   "license": "MIT",
   "author": {
@@ -37,7 +37,8 @@
     "test:e2e": "pnpm run clean && pnpm run build && tsx tests/run.ts",
     "clean": "rm -rf dist",
     "test:mutation": "stryker run",
-    "check:presets": "tsx scripts/check-preset-packages.ts"
+    "check:presets": "tsx scripts/check-preset-packages.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   },
   "dependencies": {
     "chalk": "^4.1.2",