audit0 0.1.0

package/dist/engine/inspect.mjs

@@ -0,0 +1,239 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { hoverBeforeClick, inspectState } from "./navigation.mjs";
+import { defaultSettings } from "./settings.mjs";
+const HTML_LIMIT = 60000;
+const LINK_LIMIT = 200;
+const HEADING_LIMIT = 40;
+const PRINTED_LINK_LIMIT = 40;
+const EVALUATE_RETRIES = 50;
+const AFTER_CLICK_CAPTURES = [
+    ["after-click", 0],
+    ["after-1s", 1000],
+    ["after-5s", 4000],
+];
+/**
+ * Resolves an inspect target (a path or absolute URL) against the audit origin and refuses
+ * anything outside it.
+ */
+export function resolveInspectUrl(target, origin) {
+    if (!URL.canParse(target) && !origin) {
+        throw new Error("Pass a full URL, or set --origin, AUDIT_ORIGIN or a config origin");
+    }
+    const url = new URL(target, origin ?? undefined);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+        throw new Error("Inspect URLs must be credential-free HTTP(S) URLs");
+    }
+    if (origin && url.origin !== new URL(origin).origin) {
+        throw new Error(`${url.href} is outside the audit origin ${new URL(origin).origin}`);
+    }
+    return url.href;
+}
+export function formatInspectCapture(capture) {
+    const lines = [
+        `${capture.name}${capture.status === null ? "" : ` · HTTP ${capture.status}`} · ${capture.url} · "${capture.title}"`,
+    ];
+    if (capture.redirectedFrom) {
+        lines.push(`  redirected from ${capture.redirectedFrom}; use ${new URL(capture.url).pathname} as the page path`);
+    }
+    if (capture.page) {
+        const milestones = capture.page.activeMilestones.length
+            ? ` · milestones ${capture.page.activeMilestones.join(", ")}`
+            : "";
+        const counts = Object.entries(capture.page.counts)
+            .map(([name, count]) => `${name}=${count}`)
+            .join(" ");
+        lines.push(`  page ${capture.page.id}: ${capture.page.state}${milestones} · ${counts}`);
+    }
+    for (const check of capture.selectors) {
+        lines.push(check.error
+            ? `  selector ${check.selector}: invalid (${check.error})`
+            : `  selector ${check.selector}: ${check.matches} matches, ${check.visible} audit-visible`);
+    }
+    lines.push(`  headings: ${capture.headings.map((heading) => `${heading.tag} ${heading.text}`).join(" · ") || "none"}`);
+    lines.push(`  links (${capture.links.length} visible, same-origin):`);
+    for (const link of capture.links.slice(0, PRINTED_LINK_LIMIT)) {
+        lines.push(`    ${link.href}  "${link.text}"  ${link.width}×${link.height}`);
+    }
+    if (capture.links.length > PRINTED_LINK_LIMIT) {
+        lines.push(`    … ${capture.links.length - PRINTED_LINK_LIMIT} more in ${capture.name}.json`);
+    }
+    return `${lines.join("\n")}\n`;
+}
+// Runs in the page; must stay self-contained.
+function snapshotPage({ selectors, htmlLimit, linkLimit, headingLimit }) {
+    const rendered = (el) => {
+        const rect = el.getBoundingClientRect();
+        return (rect.width > 0 &&
+            rect.height > 0 &&
+            el.checkVisibility({ opacityProperty: true, visibilityProperty: true }));
+    };
+    const label = (el) => (el.innerText?.trim() || el.getAttribute("aria-label") || "").replace(/\s+/g, " ").slice(0, 160);
+    const size = (el) => {
+        const rect = el.getBoundingClientRect();
+        return { width: Math.round(rect.width), height: Math.round(rect.height) };
+    };
+    const sameOrigin = (el) => {
+        if (el.getAttribute("href").startsWith("#"))
+            return false;
+        try {
+            return new URL(el.href).origin === location.origin;
+        }
+        catch {
+            return false;
+        }
+    };
+    return {
+        url: location.href,
+        title: document.title,
+        headings: [...document.querySelectorAll("h1, h2, h3")]
+            .filter(rendered)
+            .slice(0, headingLimit)
+            .map((el) => ({ tag: el.tagName.toLowerCase(), text: label(el) })),
+        links: [...document.querySelectorAll("a[href]")]
+            .filter((el) => rendered(el) && sameOrigin(el))
+            .slice(0, linkLimit)
+            .map((el) => ({ href: el.getAttribute("href"), text: label(el), ...size(el) })),
+        selectors: selectors.map((selector) => {
+            try {
+                return { selector, matches: document.querySelectorAll(selector).length, error: null };
+            }
+            catch (error) {
+                return { selector, matches: 0, error: String(error.message ?? error) };
+            }
+        }),
+        html: (document.querySelector("main") ?? document.body).outerHTML.slice(0, htmlLimit),
+    };
+}
+async function evaluateSettled(page, callback, argument) {
+    for (let attempt = 0;; attempt++) {
+        try {
+            return await page.evaluate(callback, argument);
+        }
+        catch (error) {
+            const navigating = /Execution context was destroyed|Cannot find context/.test(error.message);
+            if (!navigating || attempt >= EVALUATE_RETRIES)
+                throw error;
+            await page.waitForTimeout(100);
+        }
+    }
+}
+function selectorSpec(selectors) {
+    return {
+        path: "",
+        markers: Object.fromEntries(selectors.map((selector) => [selector, { selector, min: 1 }])),
+        primary: [],
+    };
+}
+async function capture(page, name, { directory, selectors, pages, status, requestedPath = null }) {
+    await page.screenshot({ path: `${directory}/${name}.png`, timeout: 10000 });
+    const snapshot = await evaluateSettled(page, snapshotPage, {
+        selectors,
+        htmlLimit: HTML_LIMIT,
+        linkLimit: LINK_LIMIT,
+        headingLimit: HEADING_LIMIT,
+    });
+    const valid = snapshot.selectors.filter((check) => !check.error).map((check) => check.selector);
+    const audited = valid.length
+        ? (await evaluateSettled(page, inspectState, selectorSpec(valid))).counts
+        : {};
+    const selectorChecks = snapshot.selectors.map((check) => ({
+        ...check,
+        visible: check.error ? 0 : audited[check.selector],
+    }));
+    const pathname = new URL(snapshot.url).pathname;
+    const spec = pages.find((candidate) => candidate.path === pathname);
+    const state = spec ? await evaluateSettled(page, inspectState, spec) : null;
+    const result = {
+        name,
+        status,
+        redirectedFrom: requestedPath !== null && requestedPath !== pathname ? requestedPath : null,
+        ...snapshot,
+        selectors: selectorChecks,
+        page: spec
+            ? {
+                id: spec.id,
+                state: state.state,
+                shell: state.shell,
+                primary: state.primary,
+                complete: state.complete,
+                activeMilestones: state.activeMilestones,
+                counts: state.counts,
+            }
+            : null,
+        screenshot: `${name}.png`,
+    };
+    await writeFile(`${directory}/${name}.json`, JSON.stringify(result, null, 2));
+    return result;
+}
+/**
+ * Opens one URL like an audit case and saves evidence for writing markers and journeys:
+ * a screenshot, visible headings and same-origin links (with rendered size), ad-hoc selector
+ * counts, the configured page's marker state, and the main HTML. With `click`, it hovers and
+ * clicks the first visible `a[href]` whose attribute exactly equals `click` — the same target a
+ * journey uses — and captures again after the click, 1s and 5s.
+ *
+ * @param {object} options
+ * @param {string} options.url
+ * @param {string | null} [options.click]
+ * @param {string[]} [options.selectors]
+ * @param {readonly import("../config/types.ts").PageSpec[]} [options.pages]
+ * @param {import("../config/types.ts").AuditSettings} [options.settings]
+ * @param {string} [options.outputDirectory]
+ * @param {boolean} [options.headed]
+ * @param {(capture: any) => void} [options.onCapture] Called as each capture is saved.
+ */
+export async function inspectUrl({ url, click = null, selectors = [], pages = [], settings = defaultSettings, outputDirectory = "artifacts/inspect", headed = false, onCapture = () => { }, }) {
+    const target = new URL(url);
+    if (click && new URL(click, target).origin !== target.origin) {
+        throw new Error(`Refusing to click a cross-origin link: ${click}`);
+    }
+    const directory = resolve(outputDirectory, `inspect-${new Date().toISOString().replaceAll(":", "-")}`);
+    await mkdir(directory, { recursive: true });
+    const { chromium } = await import("@playwright/test");
+    const browser = await chromium.launch({ headless: !headed });
+    try {
+        const context = await browser.newContext({
+            viewport: settings.viewport,
+            colorScheme: "light",
+            timezoneId: "UTC",
+            locale: "en-US",
+        });
+        const page = await context.newPage();
+        const response = await page.goto(target.href, { waitUntil: "domcontentloaded", timeout: 60000 });
+        await page.waitForTimeout(settings.pageObservationMs);
+        const options = { directory, selectors, pages };
+        const captures = [];
+        const record = async (name, status, requestedPath = null) => {
+            const result = await capture(page, name, { ...options, status, requestedPath });
+            captures.push(result);
+            onCapture(result);
+        };
+        await record("initial", response?.status() ?? null, target.pathname);
+        if (click) {
+            const link = page
+                .locator(`a[href=${JSON.stringify(click)}]`)
+                .filter({ visible: true })
+                .first();
+            if (!(await link.count())) {
+                throw new Error(`No visible link with href exactly "${click}" on ${target.pathname}; a journey to it would fail. Evidence: ${directory}`);
+            }
+            try {
+                await hoverBeforeClick(link, settings);
+                await link.click({ timeout: 10000, noWaitAfter: true });
+            }
+            catch (error) {
+                const reason = error.message.match(/<\w.*? intercepts pointer events/)?.[0];
+                throw new Error(`Could not hover and click "${click}" (${reason ?? error.message.split("\n")[0]}); a journey to it would fail. Evidence: ${directory}`);
+            }
+            for (const [name, delayMs] of AFTER_CLICK_CAPTURES) {
+                await page.waitForTimeout(delayMs);
+                await record(name, null);
+            }
+        }
+        return { directory, captures };
+    }
+    finally {
+        await browser.close();
+    }
+}

package/dist/engine/navigation-requests.d.mts

@@ -0,0 +1,50 @@
+export declare function classifyNavigationRsc({ requestHeaders, startMs, initialPriority }: {
+    initialPriority: any;
+    requestHeaders?: {} | undefined;
+    startMs: any;
+}): {
+    role: string;
+    confidence: string;
+};
+export declare function startNavigationRequestCapture(page: any, destination: any): Promise<{
+    finish(clickEpochMs: any): Promise<{
+        id: any;
+        url: string;
+        role: string;
+        confidence: string;
+        segmentPath: any;
+        prefetchKind: any;
+        hasRouterState: boolean;
+        nextUrl: string | null;
+        responseHeaders: any;
+        matchedPath: any;
+        rewrittenPath: any;
+        postponed: any;
+        prerender: any;
+        cache: any;
+        resourceType: any;
+        status: any;
+        statusCode: any;
+        startMs: number;
+        responseMs: number | null;
+        endMs: number | null;
+        durationMs: number | null;
+        timingStartMs: number | null;
+        ttfbMs: any;
+        timingSource: any;
+        resourceTiming: any;
+        protocol: any;
+        connectionId: any;
+        connectionReused: any;
+        remoteIPAddress: any;
+        encodedDataLength: any;
+        initialPriority: any;
+        finalPriority: any;
+        fromDiskCache: any;
+        fromPrefetchCache: any;
+        fromServiceWorker: any;
+        canceled: any;
+        blockedReason: any;
+    }[]>;
+    dispose: () => Promise<void>;
+}>;

package/dist/engine/navigation-requests.mjs

@@ -0,0 +1,272 @@
+import { responseTiming, sanitizeUrl } from "./page-diagnostics.mjs";
+const REQUEST_LIMIT = 200;
+const MAX_METADATA_LENGTH = 4096;
+const REQUEST_HEADERS = [
+    "rsc",
+    "next-router-prefetch",
+    "next-router-segment-prefetch",
+    "next-router-state-tree",
+    "next-url",
+    "next-hmr-refresh",
+];
+const RESPONSE_HEADERS = [
+    "age",
+    "cache-control",
+    "content-type",
+    "server-timing",
+    "x-matched-path",
+    "x-nextjs-postponed",
+    "x-nextjs-prerender",
+    "x-nextjs-cache",
+    "x-nextjs-rewritten-path",
+    "x-vercel-cache",
+    "x-vercel-id",
+];
+function lowerHeaders(headers = {}) {
+    return Object.fromEntries(Object.entries(headers).map(([name, content]) => [name.toLowerCase(), String(content)]));
+}
+function selectHeaders(headers, names) {
+    const selected = {};
+    for (const name of names) {
+        if (headers[name] !== undefined)
+            selected[name] = headers[name].slice(0, MAX_METADATA_LENGTH);
+    }
+    return selected;
+}
+function normalizedDestination(raw) {
+    try {
+        const url = new URL(raw);
+        url.hash = "";
+        url.searchParams.delete("_rsc");
+        return url.href;
+    }
+    catch {
+        return null;
+    }
+}
+function isFlightUrl(raw) {
+    try {
+        const url = new URL(raw);
+        return (url.searchParams.has("_rsc") ||
+            /(?:\.rsc|\.segment\.rsc|__next\..*\.txt)$/i.test(url.pathname));
+    }
+    catch {
+        return false;
+    }
+}
+export function classifyNavigationRsc({ requestHeaders = {}, startMs, initialPriority }) {
+    const segmentPath = requestHeaders["next-router-segment-prefetch"] ?? null;
+    const prefetchKind = requestHeaders["next-router-prefetch"] ?? null;
+    if (segmentPath === "/_tree")
+        return { role: "route-tree", confidence: "explicit" };
+    if (segmentPath)
+        return { role: "segment-prefetch", confidence: "explicit" };
+    if (prefetchKind === "3")
+        return { role: "app-shell-prefetch", confidence: "explicit" };
+    if (prefetchKind === "2")
+        return { role: "runtime-prefetch", confidence: "explicit" };
+    if (prefetchKind === "1")
+        return { role: "loading-boundary-prefetch", confidence: "explicit" };
+    if (startMs < 0 && String(initialPriority).toLowerCase() === "low") {
+        return { role: "full-prefetch", confidence: "probable" };
+    }
+    if (requestHeaders["next-router-state-tree"]) {
+        return { role: "navigation", confidence: "probable" };
+    }
+    return { role: "flight", confidence: "target-match" };
+}
+export async function startNavigationRequestCapture(page, destination) {
+    const destinationUrl = normalizedDestination(destination);
+    if (!destinationUrl)
+        throw new Error("Navigation request capture requires an absolute destination URL");
+    const session = await page.context().newCDPSession(page);
+    const requests = [];
+    const active = new Map();
+    const listeners = [];
+    let disposed = false;
+    const listen = (name, callback) => {
+        session.on(name, callback);
+        listeners.push([name, callback]);
+    };
+    const eventEpoch = (request, timestamp) => request.startEpochMs + (timestamp - request.monotonic) * 1000;
+    const applyResponse = (request, response, epochMs) => {
+        const headers = lowerHeaders(response.headers);
+        request.responseHeaders = selectHeaders(headers, RESPONSE_HEADERS);
+        request.responseEpochMs = epochMs;
+        request.statusCode = response.status;
+        request.mimeType = response.mimeType ?? null;
+        request.fromDiskCache = response.fromDiskCache ?? false;
+        request.fromPrefetchCache = response.fromPrefetchCache ?? false;
+        request.fromServiceWorker = response.fromServiceWorker ?? false;
+        request.protocol = response.protocol ?? null;
+        request.connectionId = response.connectionId ?? null;
+        request.connectionReused = response.connectionReused ?? null;
+        request.remoteIPAddress = response.remoteIPAddress ?? null;
+        request.resourceTiming = response.timing ?? null;
+        Object.assign(request, responseTiming(response.timing));
+    };
+    listen("Network.requestWillBeSent", (event) => {
+        if (disposed || normalizedDestination(event.request.url) !== destinationUrl)
+            return;
+        const previous = active.get(event.requestId);
+        if (previous && event.redirectResponse) {
+            applyResponse(previous, event.redirectResponse, eventEpoch(previous, event.timestamp));
+            previous.status = "redirected";
+            previous.endEpochMs = eventEpoch(previous, event.timestamp);
+        }
+        active.delete(event.requestId);
+        if (requests.length >= REQUEST_LIMIT)
+            return;
+        const headers = lowerHeaders(event.request.headers);
+        const request = {
+            id: `${event.requestId}:${requests.length}`,
+            requestId: event.requestId,
+            url: event.request.url,
+            resourceType: event.type ?? "Other",
+            startEpochMs: event.wallTime * 1000,
+            monotonic: event.timestamp,
+            requestHeaders: selectHeaders(headers, REQUEST_HEADERS),
+            initialPriority: event.request.initialPriority ?? null,
+            finalPriority: event.request.initialPriority ?? null,
+            status: "pending",
+            ttfbMs: null,
+            source: "unavailable",
+        };
+        requests.push(request);
+        active.set(event.requestId, request);
+    });
+    listen("Network.requestWillBeSentExtraInfo", (event) => {
+        const request = active.get(event.requestId);
+        if (!request || disposed)
+            return;
+        request.requestHeaders = {
+            ...request.requestHeaders,
+            ...selectHeaders(lowerHeaders(event.headers), REQUEST_HEADERS),
+        };
+    });
+    listen("Network.resourceChangedPriority", (event) => {
+        const request = active.get(event.requestId);
+        if (request && !disposed)
+            request.finalPriority = event.newPriority;
+    });
+    listen("Network.responseReceived", (event) => {
+        const request = active.get(event.requestId);
+        if (!request || disposed)
+            return;
+        request.resourceType = event.type ?? request.resourceType;
+        applyResponse(request, event.response, eventEpoch(request, event.timestamp));
+    });
+    listen("Network.loadingFinished", (event) => {
+        const request = active.get(event.requestId);
+        if (!request || disposed)
+            return;
+        request.endEpochMs = eventEpoch(request, event.timestamp);
+        request.encodedDataLength = event.encodedDataLength;
+        request.status = "finished";
+        active.delete(event.requestId);
+    });
+    listen("Network.loadingFailed", (event) => {
+        const request = active.get(event.requestId);
+        if (!request || disposed)
+            return;
+        request.endEpochMs = eventEpoch(request, event.timestamp);
+        request.status = "failed";
+        request.canceled = event.canceled ?? false;
+        request.blockedReason = event.blockedReason ?? null;
+        active.delete(event.requestId);
+    });
+    async function dispose() {
+        if (disposed)
+            return;
+        disposed = true;
+        for (const [name, callback] of listeners)
+            session.off(name, callback);
+        active.clear();
+        await session.detach().catch(() => { });
+    }
+    try {
+        await session.send("Network.enable", { maxPostDataSize: 0 });
+    }
+    catch (error) {
+        await dispose();
+        throw error;
+    }
+    return {
+        async finish(clickEpochMs) {
+            const serialized = requests.flatMap((request) => {
+                const contentType = request.responseHeaders?.["content-type"] ?? request.mimeType ?? "";
+                const rsc = request.requestHeaders.rsc === "1" ||
+                    isFlightUrl(request.url) ||
+                    contentType.toLowerCase().startsWith("text/x-component");
+                const document = request.resourceType === "Document";
+                if ((!rsc && !document) || request.requestHeaders["next-hmr-refresh"])
+                    return [];
+                const startMs = request.startEpochMs - clickEpochMs;
+                if (document && startMs < -50)
+                    return [];
+                const timingStartMs = Number.isFinite(request.resourceTiming?.requestTime)
+                    ? startMs + (request.resourceTiming.requestTime - request.monotonic) * 1000
+                    : null;
+                const endMs = Number.isFinite(request.endEpochMs) ? request.endEpochMs - clickEpochMs : null;
+                const responseMs = Number.isFinite(request.responseEpochMs)
+                    ? request.responseEpochMs - clickEpochMs
+                    : null;
+                const classification = document
+                    ? { role: "document", confidence: "explicit" }
+                    : classifyNavigationRsc({
+                        requestHeaders: request.requestHeaders,
+                        startMs,
+                        initialPriority: request.initialPriority,
+                    });
+                return [
+                    {
+                        id: request.id,
+                        url: sanitizeUrl(request.url),
+                        role: classification.role,
+                        confidence: classification.confidence,
+                        segmentPath: request.requestHeaders["next-router-segment-prefetch"] ?? null,
+                        prefetchKind: request.requestHeaders["next-router-prefetch"] ?? null,
+                        hasRouterState: Boolean(request.requestHeaders["next-router-state-tree"]),
+                        nextUrl: request.requestHeaders["next-url"]
+                            ? sanitizeUrl(request.requestHeaders["next-url"])
+                            : null,
+                        responseHeaders: request.responseHeaders ?? {},
+                        matchedPath: request.responseHeaders?.["x-matched-path"] ?? null,
+                        rewrittenPath: request.responseHeaders?.["x-nextjs-rewritten-path"] ?? null,
+                        postponed: request.responseHeaders?.["x-nextjs-postponed"] ?? null,
+                        prerender: request.responseHeaders?.["x-nextjs-prerender"] ?? null,
+                        cache: request.responseHeaders?.["x-vercel-cache"] ??
+                            request.responseHeaders?.["x-nextjs-cache"] ??
+                            null,
+                        resourceType: request.resourceType,
+                        status: request.status,
+                        statusCode: request.statusCode ?? null,
+                        startMs,
+                        responseMs,
+                        endMs,
+                        durationMs: endMs === null ? null : endMs - startMs,
+                        timingStartMs,
+                        ttfbMs: request.ttfbMs,
+                        timingSource: request.source,
+                        resourceTiming: request.resourceTiming,
+                        protocol: request.protocol ?? null,
+                        connectionId: request.connectionId ?? null,
+                        connectionReused: request.connectionReused ?? null,
+                        remoteIPAddress: request.remoteIPAddress ?? null,
+                        encodedDataLength: request.encodedDataLength ?? null,
+                        initialPriority: request.initialPriority,
+                        finalPriority: request.finalPriority,
+                        fromDiskCache: request.fromDiskCache ?? false,
+                        fromPrefetchCache: request.fromPrefetchCache ?? false,
+                        fromServiceWorker: request.fromServiceWorker ?? false,
+                        canceled: request.canceled ?? null,
+                        blockedReason: request.blockedReason ?? null,
+                    },
+                ];
+            });
+            await dispose();
+            return serialized;
+        },
+        dispose,
+    };
+}

package/dist/engine/navigation.d.mts

@@ -0,0 +1,91 @@
+export declare function inspectState(spec: any): {
+    path: any;
+    route: boolean;
+    shell: any;
+    primary: any;
+    complete: any;
+    activeMilestones: any;
+    counts: {};
+    fallbackCount: number | null;
+    indicators: any;
+    state: string;
+};
+export declare function waitForContent(page: any, spec: any, timeout?: number): Promise<void>;
+export declare function summarizeNavigation(samples: any, clickEpochMs: any, observationMs?: number, milestones?: any[]): {
+    clickToFeedbackMs: any;
+    firstFeedbackReasons: any;
+    clickToUrlMs: any;
+    clickToShellMs: any;
+    clickToUsefulMs: any;
+    clickToCompleteMs: any;
+    milestoneTimings: any;
+    checkpoints: {
+        requestedMs: any;
+        lastObservedMs: any;
+        nextObservedMs: any;
+        state: any;
+        activeMilestones: any;
+        counts: any;
+    }[];
+    timeline: any[];
+};
+export declare function hoverBeforeClick(target: any, settings?: {
+    repeats: number;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    sourceDwellMs: number;
+    preClickHoverMs: number;
+    pageObservationMs: number;
+    navigationObservationMs: number;
+}): Promise<void>;
+export declare function waitForClientReadyLink(target: any, timeout?: number): Promise<void>;
+/**
+ * @param {import('@playwright/test').Page} page
+ * @param {object} spec
+ * @param {object} [options]
+ * @param {string} [options.directory]
+ * @param {number} [options.observeMs]
+ * @param {boolean} [options.requireClientReady]
+ * @param {object} [options.requestCapture]
+ * @param {object} [options.settings]
+ */
+export declare function measureNavigation(page: import('@playwright/test').Page, spec: object, { directory, observeMs, requireClientReady, requestCapture: suppliedRequestCapture, settings, }?: {
+    directory?: string;
+    observeMs?: number;
+    requireClientReady?: boolean;
+    requestCapture?: object;
+    settings?: object;
+}): Promise<{
+    clickToFeedbackMs: any;
+    firstFeedbackReasons: any;
+    clickToUrlMs: any;
+    clickToShellMs: any;
+    clickToUsefulMs: any;
+    clickToCompleteMs: any;
+    milestoneTimings: any;
+    checkpoints: {
+        requestedMs: any;
+        lastObservedMs: any;
+        nextObservedMs: any;
+        state: any;
+        activeMilestones: any;
+        counts: any;
+    }[];
+    timeline: any[];
+    type: string;
+    observationMs: number;
+    endReason: any;
+    preClickHoverMs: any;
+    clientReadyWaitMs: number | null;
+    collectedAtMs: number | null;
+    finalState: any;
+    collectionErrors: string[];
+    droppedFrames: number;
+    clickEpochMs: any;
+    clickHandlerDelayMs: number;
+    finalUrl: string;
+    requests: any;
+    frames: any[];
+}>;