electron-verify-mcp 0.0.1

package/dist/core/signals/blankScreen.d.ts

@@ -0,0 +1,30 @@
+import type { Page } from "playwright-core";
+import type { BlankScreenSignal, HoleRect } from "../types.js";
+export interface BlankScreenOptions {
+    /** PNG buffer of the *raw* (or annotated) screenshot in page coordinates. */
+    png: Buffer;
+    /**
+     * BrowserView holes in the same coordinate space as `png` *before* any
+     * downscale applied for token savings. Prefer analyzing pre-downscale when
+     * possible; if the buffer was downscaled, pass holes already scaled to match.
+     */
+    holes?: HoleRect[];
+    /** Dominant-color coverage above this → pixel-blank. Default 0.98. */
+    coverageThreshold?: number;
+    /**
+     * When false (readiness timed out / not stable), do not hard-FAIL blank for
+     * sparse DOM (spinner splash). Default true if omitted.
+     */
+    readinessStable?: boolean;
+}
+/**
+ * Blank-screen detector: pixels near-uniform AND DOM effectively empty.
+ * Hole regions (BrowserViews) are excluded from the pixel histogram so the
+ * native-view void does not trigger a false blank FAIL.
+ *
+ * When visibleElements < 2, only call blank if there are also zero interactive
+ * elements AND readiness stabilized — a single spinner on a solid bg must not FAIL.
+ *
+ * dominantColor / coverage stay INTERNAL — only isBlank + reason are reported.
+ */
+export declare function detectBlankScreen(page: Page, opts: BlankScreenOptions): Promise<BlankScreenSignal>;

package/dist/core/signals/blankScreen.js

@@ -0,0 +1,106 @@
+import { PNG } from "pngjs";
+import { isInsideHole } from "../screenshot.js";
+/**
+ * Blank-screen detector: pixels near-uniform AND DOM effectively empty.
+ * Hole regions (BrowserViews) are excluded from the pixel histogram so the
+ * native-view void does not trigger a false blank FAIL.
+ *
+ * When visibleElements < 2, only call blank if there are also zero interactive
+ * elements AND readiness stabilized — a single spinner on a solid bg must not FAIL.
+ *
+ * dominantColor / coverage stay INTERNAL — only isBlank + reason are reported.
+ */
+export async function detectBlankScreen(page, opts) {
+    const holes = opts.holes ?? [];
+    const coverageThreshold = opts.coverageThreshold ?? 0.98;
+    const readinessStable = opts.readinessStable !== false;
+    const pixelBlank = isPixelNearUniform(opts.png, holes, coverageThreshold);
+    const dom = await readDomEmptiness(page);
+    // Blank only when there is essentially no UI: no text, zero sized elements,
+    // zero interactive controls, and readiness stabilized.
+    // A single spinner (visibleEls=1) on a solid bg must NOT count as empty —
+    // the old `visible < 2` threshold false-FAILed splash screens.
+    const domEmpty = dom.textLen < 2 &&
+        dom.visible === 0 &&
+        dom.interactive === 0 &&
+        readinessStable;
+    if (pixelBlank.nearUniform && domEmpty) {
+        return {
+            isBlank: true,
+            reason: `pixel-uniform (${(pixelBlank.coverage * 100).toFixed(1)}% one color) and DOM empty (${dom.detail})`,
+        };
+    }
+    return { isBlank: false, reason: null };
+}
+function isPixelNearUniform(pngBuf, holes, threshold) {
+    const img = PNG.sync.read(pngBuf);
+    // Quantize RGB to 4-bit/channel buckets so anti-aliasing doesn't fragment the histogram.
+    const hist = new Map();
+    let counted = 0;
+    for (let y = 0; y < img.height; y++) {
+        for (let x = 0; x < img.width; x++) {
+            if (holes.length && isInsideHole(x, y, holes))
+                continue;
+            const i = (img.width * y + x) << 2;
+            if (img.data[i + 3] < 16)
+                continue;
+            const r = img.data[i] >> 4;
+            const g = img.data[i + 1] >> 4;
+            const b = img.data[i + 2] >> 4;
+            const key = (r << 8) | (g << 4) | b;
+            hist.set(key, (hist.get(key) ?? 0) + 1);
+            counted++;
+        }
+    }
+    if (counted === 0) {
+        return { nearUniform: true, coverage: 1 };
+    }
+    let max = 0;
+    for (const n of hist.values())
+        if (n > max)
+            max = n;
+    const coverage = max / counted;
+    return { nearUniform: coverage >= threshold, coverage };
+}
+async function readDomEmptiness(page) {
+    try {
+        const result = await page.evaluate(() => {
+            const body = document.body;
+            if (!body)
+                return { textLen: 0, visible: 0, interactive: 0 };
+            const textLen = (body.innerText || "").trim().length;
+            let visible = 0;
+            let interactive = 0;
+            const interactiveSel = "a[href], button, input, select, textarea, [role=button], [role=link], [tabindex]";
+            const all = body.querySelectorAll("*");
+            for (const el of all) {
+                const style = window.getComputedStyle(el);
+                if (style.display === "none" || style.visibility === "hidden")
+                    continue;
+                if (parseFloat(style.opacity || "1") === 0)
+                    continue;
+                const r = el.getBoundingClientRect();
+                if (r.width > 1 && r.height > 1) {
+                    visible++;
+                    if (el.matches(interactiveSel))
+                        interactive++;
+                }
+            }
+            return { textLen, visible, interactive };
+        });
+        return {
+            textLen: result.textLen,
+            visible: result.visible,
+            interactive: result.interactive,
+            detail: `textLen=${result.textLen}, visibleEls=${result.visible}, interactive=${result.interactive}`,
+        };
+    }
+    catch (err) {
+        return {
+            textLen: 0,
+            visible: 0,
+            interactive: 0,
+            detail: `dom-evaluate-failed: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+}

package/dist/core/signals/collect.d.ts

@@ -0,0 +1,21 @@
+import type { Page } from "playwright-core";
+import type { AppSession } from "../session.js";
+import type { HoleRect, ReadinessSignal, Signals } from "../types.js";
+export interface CollectOptions {
+    readiness: ReadinessSignal;
+    /** Raw (pre-annotation preferred) PNG for blank-screen pixel analysis. */
+    png: Buffer;
+    holes?: HoleRect[];
+    criticalSelectors?: string[];
+    srcGlobs?: string[];
+    /** Override page (defaults to session.page()). */
+    page?: Page;
+    /** Dominant-color coverage threshold for blank detection. */
+    blankCoverage?: number;
+}
+/**
+ * Run all signal readers against a live session → Signals object.
+ * Console / main / resources were attached at launch; we snapshot them here
+ * filtered to the selected page.
+ */
+export declare function collectSignals(session: AppSession, opts: CollectOptions): Promise<Signals>;

package/dist/core/signals/collect.js

@@ -0,0 +1,38 @@
+import { detectBlankScreen } from "./blankScreen.js";
+import { detectLayout } from "./layout.js";
+import { detectStaleBuild } from "./staleBuild.js";
+/**
+ * Run all signal readers against a live session → Signals object.
+ * Console / main / resources were attached at launch; we snapshot them here
+ * filtered to the selected page.
+ */
+export async function collectSignals(session, opts) {
+    const page = opts.page ?? session.page();
+    await session.consoleCollector.pollMainCrashes(session.app, page);
+    const consoleSig = session.consoleCollector.snapshot(page);
+    const mainProcess = session.mainProcessCollector.snapshot();
+    const resources = await session.resourcesCollector.snapshot(page);
+    const blankScreen = await detectBlankScreen(page, {
+        png: opts.png,
+        holes: opts.holes,
+        coverageThreshold: opts.blankCoverage,
+        readinessStable: opts.readiness.stable && !opts.readiness.timedOut,
+    });
+    const layout = await detectLayout(page, {
+        criticalSelectors: opts.criticalSelectors,
+    });
+    const staleBuild = detectStaleBuild({
+        cwd: session.cwd,
+        launchedAt: session.launchedAt,
+        srcGlobs: opts.srcGlobs,
+    });
+    return {
+        readiness: opts.readiness,
+        console: consoleSig,
+        mainProcess,
+        blankScreen,
+        layout,
+        resources,
+        staleBuild,
+    };
+}

package/dist/core/signals/console.d.ts

@@ -0,0 +1,62 @@
+import type { ElectronApplication, Page } from "playwright-core";
+import type { ConsoleSignal } from "../types.js";
+/**
+ * Default ignore-list for known-benign Electron / Chromium console noise.
+ * Extend via `ignoreConsolePatterns` (substring or regex source strings).
+ */
+export declare const DEFAULT_IGNORE_PATTERNS: string[];
+export interface ConsoleCollectorOptions {
+    ignoreConsolePatterns?: string[];
+}
+/**
+ * Live console / pageerror / crash collector.
+ * Messages are tagged per page; {@link snapshot} filters to the selected page.
+ * Each verify call windows "new" errors via {@link markVerifyStart}.
+ */
+export declare class ConsoleCollector {
+    private readonly ignore;
+    private readonly errors;
+    private ignored;
+    private rendererCrashed;
+    /** Index into `errors` at last markVerifyStart (session-wide; filtering is per-page). */
+    private verifyMarker;
+    private attachedPages;
+    private errorBufferInstalled;
+    private pageIds;
+    private nextPageId;
+    private mainHooksInstalled;
+    constructor(opts?: ConsoleCollectorOptions);
+    pageId(page: Page): number;
+    /** Attach page-level listeners. Safe to call for every new window. */
+    attachPage(page: Page): void;
+    /**
+     * Install a persistent renderer error buffer via addInitScript.
+     * Only installs once per page (addInitScript stacks if called repeatedly).
+     */
+    installErrorBuffer(page: Page): Promise<void>;
+    /**
+     * Read window.__evErrors into the collector, then clear.
+     * Dedupes PER-VERIFY (against messages since the marker for this page only),
+     * so a recurring error is not swallowed on later verifies, and the same throw
+     * is not double-counted from pageerror + buffer.
+     */
+    drainBufferedErrors(page: Page): Promise<number>;
+    /**
+     * Install main-process `render-process-gone` hooks tagged by webContents id.
+     * Also listens for newly created windows on the ElectronApplication.
+     */
+    attachApp(app: ElectronApplication): Promise<void>;
+    /** Call at the start of each verify so newErrors is a delta. */
+    markVerifyStart(): void;
+    /**
+     * Pull main-process crash records for the selected page's webContents only.
+     */
+    pollMainCrashes(app: ElectronApplication, selectedPage?: Page): Promise<void>;
+    /**
+     * Snapshot errors for the selected page only.
+     * When `page` is omitted, includes all pages (legacy / tests).
+     */
+    snapshot(page?: Page): ConsoleSignal;
+    private record;
+    private shouldIgnore;
+}

package/dist/core/signals/console.js

@@ -0,0 +1,335 @@
+/**
+ * Default ignore-list for known-benign Electron / Chromium console noise.
+ * Extend via `ignoreConsolePatterns` (substring or regex source strings).
+ */
+export const DEFAULT_IGNORE_PATTERNS = [
+    // DevTools Autofill protocol (Chromium noise when DevTools domains missing)
+    "Autofill.enable",
+    "Autofill.setAddresses",
+    "Request Autofill",
+    // Electron security / deprecation warnings (not app bugs)
+    "Electron Security Warning",
+    "Insecure Content-Security-Policy",
+    // Chromium GPU / disk cache noise
+    "GPU process",
+    "gpu_process",
+    "disk_cache",
+    "DiskCache",
+    "Failed to create GLES",
+    "GPU stall",
+    "SharedImageManager",
+    // Common harmless preload / favicon noise
+    "was preloaded using link preload but not used",
+    "Failed to load resource: the server responded with a status of 404", // favicon etc.; resources signal covers real failures
+];
+/**
+ * Live console / pageerror / crash collector.
+ * Messages are tagged per page; {@link snapshot} filters to the selected page.
+ * Each verify call windows "new" errors via {@link markVerifyStart}.
+ */
+export class ConsoleCollector {
+    ignore;
+    errors = [];
+    ignored = 0;
+    rendererCrashed = false;
+    /** Index into `errors` at last markVerifyStart (session-wide; filtering is per-page). */
+    verifyMarker = 0;
+    attachedPages = new WeakSet();
+    errorBufferInstalled = new WeakSet();
+    pageIds = new WeakMap();
+    nextPageId = 1;
+    mainHooksInstalled = false;
+    constructor(opts = {}) {
+        const patterns = [
+            ...DEFAULT_IGNORE_PATTERNS,
+            ...(opts.ignoreConsolePatterns ?? []),
+        ];
+        this.ignore = patterns.map((p) => {
+            try {
+                return new RegExp(p, "i");
+            }
+            catch {
+                return new RegExp(escapeRegExp(p), "i");
+            }
+        });
+    }
+    pageId(page) {
+        let id = this.pageIds.get(page);
+        if (id === undefined) {
+            id = this.nextPageId++;
+            this.pageIds.set(page, id);
+        }
+        return id;
+    }
+    /** Attach page-level listeners. Safe to call for every new window. */
+    attachPage(page) {
+        if (this.attachedPages.has(page))
+            return;
+        this.attachedPages.add(page);
+        const pid = this.pageId(page);
+        // Fire-and-forget install; verify() awaits installErrorBuffer for deterministic capture.
+        void this.installErrorBuffer(page);
+        page.on("console", (msg) => {
+            if (msg.type() !== "error")
+                return;
+            this.record("error", msg.text(), pid);
+        });
+        page.on("pageerror", (err) => {
+            this.record("pageerror", err.message || String(err), pid);
+        });
+        page.on("crash", () => {
+            this.rendererCrashed = true;
+            this.record("crash", "Renderer process crashed", pid);
+        });
+    }
+    /**
+     * Install a persistent renderer error buffer via addInitScript.
+     * Only installs once per page (addInitScript stacks if called repeatedly).
+     */
+    async installErrorBuffer(page) {
+        if (this.errorBufferInstalled.has(page))
+            return;
+        this.errorBufferInstalled.add(page);
+        await page.addInitScript(() => {
+            const w = window;
+            w.__evErrors = w.__evErrors ?? [];
+            if (window.__evErrorsHooked)
+                return;
+            window.__evErrorsHooked = true;
+            window.addEventListener("error", (e) => {
+                const msg = (e.error instanceof Error ? e.error.message : null) ||
+                    e.message ||
+                    String(e.error ?? "error");
+                w.__evErrors.push(msg);
+            });
+            window.addEventListener("unhandledrejection", (e) => {
+                const reason = e.reason;
+                const msg = reason instanceof Error
+                    ? reason.message
+                    : reason != null
+                        ? String(reason)
+                        : "unknown";
+                // Distinct prefix so drain can tag type=unhandledrejection.
+                w.__evErrors.push(`unhandledrejection: ${msg}`);
+            });
+        });
+    }
+    /**
+     * Read window.__evErrors into the collector, then clear.
+     * Dedupes PER-VERIFY (against messages since the marker for this page only),
+     * so a recurring error is not swallowed on later verifies, and the same throw
+     * is not double-counted from pageerror + buffer.
+     */
+    async drainBufferedErrors(page) {
+        let buffered = [];
+        try {
+            buffered = await page.evaluate(() => {
+                const w = window;
+                const list = Array.isArray(w.__evErrors) ? [...w.__evErrors] : [];
+                w.__evErrors = [];
+                return list;
+            });
+        }
+        catch {
+            return 0;
+        }
+        const pid = this.pageId(page);
+        const windowTexts = new Set(this.errors
+            .slice(this.verifyMarker)
+            .filter((m) => m.pageId === pid)
+            .map((m) => normalizeErrorText(m.text)));
+        let added = 0;
+        for (const text of buffered) {
+            if (!text)
+                continue;
+            const isRejection = /^unhandledrejection:\s*/i.test(text);
+            const type = isRejection ? "unhandledrejection" : "pageerror";
+            // Strip prefix for rejection body; keep full text for storage/display.
+            const sliced = text.slice(0, 2000);
+            const norm = normalizeErrorText(sliced);
+            if (windowTexts.has(norm))
+                continue;
+            // Also match bare body against "unhandledrejection: body" already recorded.
+            const bare = normalizeErrorText(sliced.replace(/^unhandledrejection:\s*/i, ""));
+            if (windowTexts.has(bare) || [...windowTexts].some((t) => t.includes(bare) || bare.includes(t))) {
+                // Skip only when a close match exists in this verify window.
+                if (windowTexts.has(bare) ||
+                    [...windowTexts].some((t) => t === bare || t.endsWith(bare) || bare.endsWith(t))) {
+                    continue;
+                }
+            }
+            const before = this.errors.length;
+            this.record(type, sliced, pid);
+            if (this.errors.length > before) {
+                windowTexts.add(normalizeErrorText(sliced));
+                windowTexts.add(bare);
+                added += 1;
+            }
+        }
+        return added;
+    }
+    /**
+     * Install main-process `render-process-gone` hooks tagged by webContents id.
+     * Also listens for newly created windows on the ElectronApplication.
+     */
+    async attachApp(app) {
+        app.on("window", (page) => this.attachPage(page));
+        for (const page of app.windows()) {
+            this.attachPage(page);
+        }
+        if (this.mainHooksInstalled)
+            return;
+        this.mainHooksInstalled = true;
+        try {
+            await app.evaluate(({ app: electronApp, webContents }) => {
+                const g = globalThis;
+                g.__evVerifyCrashes = g.__evVerifyCrashes ?? [];
+                const track = (contents) => {
+                    contents.on("render-process-gone", (_event, details) => {
+                        const d = details;
+                        g.__evVerifyCrashes.push({
+                            reason: d?.reason ?? "unknown",
+                            exitCode: d?.exitCode ?? -1,
+                            webContentsId: contents.id,
+                        });
+                    });
+                };
+                electronApp.on("web-contents-created", (_e, contents) => {
+                    track(contents);
+                });
+                for (const wc of webContents.getAllWebContents()) {
+                    track(wc);
+                }
+            });
+        }
+        catch {
+            // Some Electron/Playwright combos reject evaluate early; page crash still works.
+        }
+    }
+    /** Call at the start of each verify so newErrors is a delta. */
+    markVerifyStart() {
+        this.verifyMarker = this.errors.length;
+    }
+    /**
+     * Pull main-process crash records for the selected page's webContents only.
+     */
+    async pollMainCrashes(app, selectedPage) {
+        let selectedWcId = null;
+        if (selectedPage) {
+            try {
+                const url = selectedPage.url();
+                selectedWcId = await app.evaluate(({ BrowserWindow, webContents }, pageUrl) => {
+                    const byUrl = BrowserWindow.getAllWindows().find((w) => w.webContents.getURL() === pageUrl);
+                    if (byUrl)
+                        return byUrl.webContents.id;
+                    // Fallback: match any webContents with this URL (BrowserView case rare here).
+                    for (const wc of webContents.getAllWebContents()) {
+                        try {
+                            if (wc.getURL() === pageUrl)
+                                return wc.id;
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                    return null;
+                }, url);
+            }
+            catch {
+                selectedWcId = null;
+            }
+        }
+        try {
+            const crashes = await app.evaluate(() => {
+                const g = globalThis;
+                const list = g.__evVerifyCrashes ?? [];
+                g.__evVerifyCrashes = [];
+                return list;
+            });
+            for (const c of crashes ?? []) {
+                // Scope to selected window when we know its webContents id.
+                if (selectedWcId != null && c.webContentsId !== selectedWcId) {
+                    continue;
+                }
+                this.rendererCrashed = true;
+                const pid = selectedPage ? this.pageId(selectedPage) : 0;
+                this.record("crash", `render-process-gone: ${c.reason} (exit ${c.exitCode})`, pid, c.webContentsId);
+            }
+        }
+        catch {
+            // App may already be gone.
+        }
+    }
+    /**
+     * Snapshot errors for the selected page only.
+     * When `page` is omitted, includes all pages (legacy / tests).
+     */
+    snapshot(page) {
+        const pid = page ? this.pageId(page) : null;
+        const forPage = (m) => (pid == null ? true : m.pageId === pid);
+        const sessionMsgs = this.errors.filter(forPage);
+        const newSlice = this.errors.slice(this.verifyMarker).filter(forPage);
+        // Deduplicate within the verify window by normalized text (pageerror + buffer).
+        const dedupedNew = dedupeMessages(newSlice);
+        const hard = dedupedNew.filter((m) => m.type === "pageerror" || m.type === "crash");
+        const consoleErrs = dedupedNew.filter((m) => m.type === "error");
+        const rejections = dedupedNew.filter((m) => m.type === "unhandledrejection");
+        // Crash on any page still surfaces if it was scoped to selected; page-level crash
+        // already sets rendererCrashed only when that page fires — but other pages also
+        // set it. Recompute: crashed only if a crash message is in this page's session.
+        const pageCrashed = sessionMsgs.some((m) => m.type === "crash") ||
+            (page ? false : this.rendererCrashed);
+        return {
+            newErrors: dedupedNew.length,
+            newHardErrors: hard.length,
+            newConsoleErrors: consoleErrs.length,
+            newUnhandledRejections: rejections.length,
+            sessionErrors: sessionMsgs.length,
+            ignored: this.ignored,
+            messages: sessionMsgs.slice(-50).map(({ type, text, ts }) => ({ type, text, ts })),
+            rendererCrashed: pageCrashed,
+        };
+    }
+    record(type, text, pageId, webContentsId) {
+        if (this.shouldIgnore(text)) {
+            this.ignored += 1;
+            return;
+        }
+        this.errors.push({
+            type,
+            text: text.slice(0, 2000),
+            ts: Date.now(),
+            pageId,
+            webContentsId,
+        });
+    }
+    shouldIgnore(text) {
+        return this.ignore.some((re) => re.test(text));
+    }
+}
+function normalizeErrorText(text) {
+    return text
+        .replace(/^unhandledrejection:\s*/i, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .toLowerCase()
+        .slice(0, 500);
+}
+function dedupeMessages(msgs) {
+    const seen = new Set();
+    const out = [];
+    for (const m of msgs) {
+        const key = `${m.type === "pageerror" || m.type === "unhandledrejection" || m.type === "error" ? "e" : m.type}:${normalizeErrorText(m.text)}`;
+        // Collapse pageerror + buffer duplicate of same throw.
+        const normKey = normalizeErrorText(m.text);
+        if (seen.has(normKey))
+            continue;
+        seen.add(normKey);
+        seen.add(key);
+        out.push(m);
+    }
+    return out;
+}
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}

package/dist/core/signals/layout.d.ts

@@ -0,0 +1,14 @@
+import type { Page } from "playwright-core";
+import type { LayoutSignal } from "../types.js";
+export interface LayoutOptions {
+    /** Selectors that must exist and have non-zero size. Missing → WARN. */
+    criticalSelectors?: string[];
+}
+/**
+ * Robust layout checks only:
+ * - horizontal document overflow (scrollWidth > clientWidth)
+ * - criticalSelectors missing or zero-size
+ *
+ * No generic zero-size / offscreen sweep (too noisy per plan).
+ */
+export declare function detectLayout(page: Page, opts?: LayoutOptions): Promise<LayoutSignal>;

package/dist/core/signals/layout.js

@@ -0,0 +1,32 @@
+/**
+ * Robust layout checks only:
+ * - horizontal document overflow (scrollWidth > clientWidth)
+ * - criticalSelectors missing or zero-size
+ *
+ * No generic zero-size / offscreen sweep (too noisy per plan).
+ */
+export async function detectLayout(page, opts = {}) {
+    const selectors = opts.criticalSelectors ?? [];
+    try {
+        return await page.evaluate((critical) => {
+            const doc = document.documentElement;
+            const documentOverflow = !!doc && doc.scrollWidth > doc.clientWidth + 1; // +1 tolerance for subpixel
+            const criticalMissing = [];
+            for (const sel of critical) {
+                const el = document.querySelector(sel);
+                if (!el) {
+                    criticalMissing.push(sel);
+                    continue;
+                }
+                const r = el.getBoundingClientRect();
+                if (r.width < 1 || r.height < 1) {
+                    criticalMissing.push(sel);
+                }
+            }
+            return { documentOverflow, criticalMissing };
+        }, selectors);
+    }
+    catch {
+        return { documentOverflow: false, criticalMissing: [] };
+    }
+}

package/dist/core/signals/mainProcess.d.ts

@@ -0,0 +1,17 @@
+import type { ElectronApplication } from "playwright-core";
+import type { MainProcessSignal } from "../types.js";
+/**
+ * Capture main-process stderr into a rolling tail and watch for exit.
+ * If the main process throws on boot this is the key diagnosis signal.
+ */
+export declare class MainProcessCollector {
+    private chunks;
+    private totalLen;
+    private exited;
+    private exitCode;
+    private attached;
+    private readonly maxTail;
+    constructor(maxTail?: number);
+    attach(app: ElectronApplication): void;
+    snapshot(): MainProcessSignal;
+}