@presto1314w/vite-devtools-browser 0.2.0 → 0.3.0

package/dist/browser.js

@@ -1,29 +1,17 @@
-import { existsSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { chromium } from "playwright";
-import * as vueDevtools from "./vue/devtools.js";
-import * as reactDevtools from "./react/devtools.js";
-import * as svelteDevtools from "./svelte/devtools.js";
+import { join } from "node:path";
+import { initBrowserEventCollector, readBrowserEvents } from "./browser-collector.js";
+import { detectBrowserFramework, inspectReactTree, inspectSvelteTree, inspectVuePinia, inspectVueRouter, inspectVueTree, } from "./browser-frameworks.js";
+import { closeBrowserSession, createBrowserSessionState, ensureBrowserPage, getCurrentPage as getSessionPage, } from "./browser-session.js";
+import { collectModuleRows, formatHmrTrace, formatModuleGraphSnapshot, formatModuleGraphTrace, formatRuntimeStatus, readOverlayError, readRuntimeSnapshot, } from "./browser-vite.js";
 import * as networkLog from "./network.js";
 import { resolveViaSourceMap } from "./sourcemap.js";
-const extensionPath = process.env.REACT_DEVTOOLS_EXTENSION ??
-    resolve(import.meta.dirname, "../../next-browser/extensions/react-devtools-chrome");
-const hasReactExtension = existsSync(join(extensionPath, "manifest.json"));
-const installHook = hasReactExtension
-    ? readFileSync(join(extensionPath, "build", "installHook.js"), "utf-8")
-    : null;
-let context = null;
-let page = null;
-let framework = "unknown";
-let extensionModeDisabled = false;
+export { contextUsable, isClosedTargetError } from "./browser-session.js";
+export { formatHmrTrace, formatModuleGraphSnapshot, formatModuleGraphTrace, formatRuntimeStatus, normalizeLimit, } from "./browser-vite.js";
+const session = createBrowserSessionState();
 let eventQueue = null;
-const consoleLogs = [];
 const MAX_LOGS = 200;
 const MAX_HMR_EVENTS = 500;
-let lastReactSnapshot = [];
-const hmrEvents = [];
-let lastModuleGraphUrls = null;
 export function setEventQueue(queue) {
     eventQueue = queue;
 }
@@ -31,84 +19,19 @@ export function getEventQueue() {
     return eventQueue;
 }
 export function getCurrentPage() {
-    if (!contextUsable(context))
-        return null;
-    if (!page || page.isClosed())
-        return null;
-    return page;
+    return getSessionPage(session);
 }
 /**
  * Inject browser-side event collector into the page
  */
 async function injectEventCollector(currentPage) {
-    await currentPage.evaluate(() => {
-        if (window.__vb_events)
-            return; // already injected
-        window.__vb_events = [];
-        window.__vb_push = (event) => {
-            const q = window.__vb_events;
-            q.push(event);
-            if (q.length > 1000)
-                q.shift();
-        };
-        // Subscribe to Vite HMR WebSocket
-        function attachViteListener() {
-            const hot = window.__vite_hot;
-            if (hot?.ws) {
-                hot.ws.addEventListener('message', (e) => {
-                    try {
-                        const data = JSON.parse(e.data);
-                        window.__vb_push({
-                            timestamp: Date.now(),
-                            type: data.type === 'error' ? 'hmr-error' : 'hmr-update',
-                            payload: data
-                        });
-                    }
-                    catch { }
-                });
-                return true;
-            }
-            return false;
-        }
-        // Retry if __vite_hot not ready yet
-        if (!attachViteListener()) {
-            let attempts = 0;
-            const timer = setInterval(() => {
-                attempts++;
-                if (attachViteListener() || attempts >= 50) {
-                    clearInterval(timer);
-                }
-            }, 100);
-        }
-        // Hook window.onerror for runtime errors
-        const origOnError = window.onerror;
-        window.onerror = (msg, src, line, col, err) => {
-            window.__vb_push({
-                timestamp: Date.now(),
-                type: 'error',
-                payload: { message: String(msg), source: src, line, col, stack: err?.stack }
-            });
-            return origOnError ? origOnError(msg, src, line, col, err) : false;
-        };
-        // Hook unhandledrejection
-        window.addEventListener('unhandledrejection', (e) => {
-            window.__vb_push({
-                timestamp: Date.now(),
-                type: 'error',
-                payload: { message: e.reason?.message, stack: e.reason?.stack }
-            });
-        });
-    });
+    await currentPage.evaluate(initBrowserEventCollector);
 }
 /**
  * Flush browser events into daemon event queue
  */
 export async function flushBrowserEvents(currentPage, queue) {
-    const raw = await currentPage.evaluate(() => {
-        const events = window.__vb_events ?? [];
-        window.__vb_events = []; // clear after flush
-        return events;
-    });
+    const raw = await currentPage.evaluate(readBrowserEvents);
     for (const e of raw) {
         queue.push(e);
     }
@@ -116,97 +39,28 @@ export async function flushBrowserEvents(currentPage, queue) {
 export async function open(url) {
     const currentPage = await ensurePage();
     if (url) {
-        await currentPage.goto(url, { waitUntil: "domcontentloaded" });
-        await injectEventCollector(currentPage);
-        await detectFramework();
+        await navigateAndRefreshContext(currentPage, () => currentPage.goto(url, { waitUntil: "domcontentloaded" }), true);
     }
 }
 export async function cookies(cookies, domain) {
-    if (!context)
+    if (!session.context)
         throw new Error("browser not open");
-    await context.addCookies(cookies.map((c) => ({ name: c.name, value: c.value, domain, path: "/" })));
+    await session.context.addCookies(cookies.map((c) => ({ name: c.name, value: c.value, domain, path: "/" })));
     return cookies.length;
 }
 export async function close() {
-    await context?.close();
-    context = null;
-    page = null;
-    framework = "unknown";
-    consoleLogs.length = 0;
-    hmrEvents.length = 0;
-    lastModuleGraphUrls = null;
+    await closeBrowserSession(session);
     networkLog.clear();
-    lastReactSnapshot = [];
 }
 async function ensurePage() {
-    if (!contextUsable(context)) {
-        await close();
-        context = await launch();
-    }
-    if (!context)
-        throw new Error("browser not open");
-    if (!page || page.isClosed()) {
-        try {
-            page = context.pages()[0] ?? (await context.newPage());
-        }
-        catch (error) {
-            if (!isClosedTargetError(error))
-                throw error;
-            await close();
-            extensionModeDisabled = true;
-            context = await launch();
-            page = context.pages()[0] ?? (await context.newPage());
-        }
-        attachListeners(page);
-        networkLog.attach(page);
-    }
-    return page;
-}
-export function contextUsable(current) {
-    if (!current)
-        return false;
-    try {
-        current.pages();
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function isClosedTargetError(error) {
-    if (!(error instanceof Error))
-        return false;
-    return /Target page, context or browser has been closed/i.test(error.message);
-}
-async function launch() {
-    if (hasReactExtension && installHook && !extensionModeDisabled) {
-        try {
-            const ctx = await chromium.launchPersistentContext("", {
-                headless: false,
-                viewport: { width: 1280, height: 720 },
-                args: [
-                    `--disable-extensions-except=${extensionPath}`,
-                    `--load-extension=${extensionPath}`,
-                    "--auto-open-devtools-for-tabs",
-                ],
-            });
-            await ctx.waitForEvent("serviceworker").catch(() => { });
-            await ctx.addInitScript(installHook);
-            return ctx;
-        }
-        catch {
-            extensionModeDisabled = true;
-        }
-    }
-    const browser = await chromium.launch({
-        headless: false,
-        args: ["--auto-open-devtools-for-tabs"],
+    return ensureBrowserPage(session, (currentPage) => {
+        attachListeners(currentPage);
+        networkLog.attach(currentPage);
     });
-    return browser.newContext({ viewport: { width: 1280, height: 720 } });
 }
 function attachListeners(currentPage) {
     currentPage.on("console", (msg) => {
-        recordConsoleMessage(consoleLogs, hmrEvents, msg.type(), msg.text());
+        recordConsoleMessage(session.consoleLogs, session.hmrEvents, msg.type(), msg.text());
     });
 }
 export function recordConsoleMessage(logs, events, type, message, maxLogs = MAX_LOGS, maxEvents = MAX_HMR_EVENTS) {
@@ -247,108 +101,9 @@ export function parseViteLog(message) {
         event.path = hotUpdateMatch[1].trim();
     return event;
 }
-export function normalizeLimit(limit, fallback, max) {
-    if (!Number.isFinite(limit) || limit <= 0)
-        return fallback;
-    return Math.min(limit, max);
-}
-export function formatRuntimeStatus(runtime, currentFramework, events) {
-    const output = [];
-    output.push("# Vite Runtime");
-    output.push(`URL: ${runtime.url}`);
-    output.push(`Framework: ${currentFramework}`);
-    output.push(`Vite Client: ${runtime.hasViteClient ? "loaded" : "not detected"}`);
-    output.push(`HMR Socket: ${runtime.wsState}`);
-    output.push(`Error Overlay: ${runtime.hasErrorOverlay ? "present" : "none"}`);
-    output.push(`Tracked HMR Events: ${events.length}`);
-    const last = events[events.length - 1];
-    if (last) {
-        output.push(`Last HMR Event: ${new Date(last.timestamp).toLocaleTimeString()} [${last.type}] ${last.message}`);
-    }
-    return output.join("\n");
-}
-export function formatHmrTrace(mode, events, limit) {
-    if (events.length === 0)
-        return "No HMR updates";
-    const safeLimit = normalizeLimit(limit, 20, 200);
-    const recent = events.slice(-safeLimit);
-    if (mode === "summary") {
-        const counts = recent.reduce((acc, event) => {
-            acc[event.type] = (acc[event.type] ?? 0) + 1;
-            return acc;
-        }, {});
-        const lines = ["# HMR Summary"];
-        lines.push(`Events considered: ${recent.length}`);
-        lines.push(`Counts: ${Object.entries(counts)
-            .map(([k, v]) => `${k}=${v}`)
-            .join(", ")}`);
-        const last = recent[recent.length - 1];
-        lines.push(`Last: ${new Date(last.timestamp).toLocaleTimeString()} [${last.type}] ${last.path ?? last.message}`);
-        lines.push("\nUse `vite-browser vite hmr trace --limit <n>` for timeline details.");
-        return lines.join("\n");
-    }
-    return [
-        "# HMR Trace",
-        ...recent.map((event) => {
-            const detail = event.path ? `${event.path}` : event.message;
-            return `[${new Date(event.timestamp).toLocaleTimeString()}] ${event.type} ${detail}`;
-        }),
-    ].join("\n");
-}
-export function formatModuleGraphSnapshot(rows, filter, limit = 200) {
-    const normalizedFilter = filter?.trim().toLowerCase();
-    const safeLimit = normalizeLimit(limit, 200, 500);
-    const filtered = rows.filter((row) => normalizedFilter ? row.url.toLowerCase().includes(normalizedFilter) : true);
-    const limited = filtered.slice(0, safeLimit);
-    if (limited.length === 0)
-        return "No module resources found";
-    const lines = [];
-    lines.push("# Vite Module Graph (loaded resources)");
-    lines.push(`Total: ${filtered.length}${filtered.length > limited.length ? ` (showing ${limited.length})` : ""}`);
-    lines.push("# idx initiator ms url");
-    lines.push("");
-    limited.forEach((row, idx) => {
-        lines.push(`${idx} ${row.initiator} ${row.durationMs}ms ${row.url}`);
-    });
-    return lines.join("\n");
-}
-export function formatModuleGraphTrace(currentUrls, previousUrls, filter, limit = 200) {
-    if (!previousUrls) {
-        return "No module-graph baseline. Captured current snapshot; run `vite module-graph trace` again.";
-    }
-    const currentSet = new Set(currentUrls);
-    const added = currentUrls.filter((url) => !previousUrls.has(url));
-    const removed = [...previousUrls].filter((url) => !currentSet.has(url));
-    const normalizedFilter = filter?.trim().toLowerCase();
-    const safeLimit = normalizeLimit(limit, 200, 500);
-    const addedFiltered = normalizedFilter
-        ? added.filter((url) => url.toLowerCase().includes(normalizedFilter))
-        : added;
-    const removedFiltered = normalizedFilter
-        ? removed.filter((url) => url.toLowerCase().includes(normalizedFilter))
-        : removed;
-    const lines = [];
-    lines.push("# Vite Module Graph Trace");
-    lines.push(`Added: ${addedFiltered.length}, Removed: ${removedFiltered.length}`);
-    lines.push("");
-    lines.push("## Added");
-    if (addedFiltered.length === 0)
-        lines.push("(none)");
-    else
-        addedFiltered.slice(0, safeLimit).forEach((url) => lines.push(`+ ${url}`));
-    lines.push("");
-    lines.push("## Removed");
-    if (removedFiltered.length === 0)
-        lines.push("(none)");
-    else
-        removedFiltered.slice(0, safeLimit).forEach((url) => lines.push(`- ${url}`));
-    return lines.join("\n");
-}
 export async function goto(url) {
     const currentPage = await ensurePage();
-    await currentPage.goto(url, { waitUntil: "domcontentloaded" });
-    await injectEventCollector(currentPage);
-    await detectFramework();
+    await navigateAndRefreshContext(currentPage, () => currentPage.goto(url, { waitUntil: "domcontentloaded" }), true);
     return currentPage.url();
 }
 export async function back() {
@@ -357,90 +112,33 @@ export async function back() {
 }
 export async function reload() {
     const currentPage = await ensurePage();
-    await currentPage.reload({ waitUntil: "domcontentloaded" });
+    await navigateAndRefreshContext(currentPage, () => currentPage.reload({ waitUntil: "domcontentloaded" }));
     return currentPage.url();
 }
 export async function detectFramework() {
-    if (!page)
-        throw new Error("browser not open");
-    const detected = await page.evaluate(() => {
-        if (window.__VUE__ || window.__VUE_DEVTOOLS_GLOBAL_HOOK__) {
-            const version = window.__VUE__?.version || "unknown";
-            return `vue@${version}`;
-        }
-        const reactHook = window.__REACT_DEVTOOLS_GLOBAL_HOOK__;
-        if (reactHook || window.React || document.querySelector("[data-reactroot]")) {
-            const renderers = reactHook?.renderers;
-            const firstRenderer = renderers ? renderers.values().next().value : null;
-            const version = firstRenderer?.version || window.React?.version || "unknown";
-            return `react@${version}`;
-        }
-        if (window.__SVELTE__ ||
-            window.__svelte ||
-            window.__SVELTE_DEVTOOLS_GLOBAL_HOOK__) {
-            const version = window.__SVELTE__?.VERSION ||
-                window.__svelte?.version ||
-                "unknown";
-            return `svelte@${version}`;
-        }
-        return "unknown";
-    });
-    if (detected.startsWith("vue"))
-        framework = "vue";
-    else if (detected.startsWith("react"))
-        framework = "react";
-    else if (detected.startsWith("svelte"))
-        framework = "svelte";
-    else
-        framework = "unknown";
-    return detected;
+    const currentPage = requireCurrentPage();
+    const result = await detectBrowserFramework(currentPage);
+    session.framework = result.framework;
+    return result.detected;
 }
 export async function vueTree(id) {
-    if (!page)
-        throw new Error("browser not open");
-    return id ? vueDevtools.getComponentDetails(page, id) : vueDevtools.getComponentTree(page);
+    return inspectVueTree(requireCurrentPage(), id);
 }
 export async function vuePinia(store) {
-    if (!page)
-        throw new Error("browser not open");
-    return vueDevtools.getPiniaStores(page, store);
+    return inspectVuePinia(requireCurrentPage(), store);
 }
 export async function vueRouter() {
-    if (!page)
-        throw new Error("browser not open");
-    return vueDevtools.getRouterInfo(page);
+    return inspectVueRouter(requireCurrentPage());
 }
 export async function reactTree(id) {
-    if (!page)
-        throw new Error("browser not open");
-    if (!id) {
-        lastReactSnapshot = await reactDevtools.snapshot(page);
-        return reactDevtools.format(lastReactSnapshot);
-    }
-    const parsed = Number.parseInt(id, 10);
-    if (!Number.isFinite(parsed))
-        throw new Error("react component id must be a number");
-    const inspected = await reactDevtools.inspect(page, parsed);
-    const lines = [];
-    const componentPath = reactDevtools.path(lastReactSnapshot, parsed);
-    if (componentPath)
-        lines.push(`path: ${componentPath}`);
-    lines.push(inspected.text);
-    if (inspected.source) {
-        const [file, line, column] = inspected.source;
-        lines.push(`source: ${file}:${line}:${column}`);
-    }
-    return lines.join("\n");
+    return inspectReactTree(session, requireCurrentPage(), id);
 }
 export async function svelteTree(id) {
-    if (!page)
-        throw new Error("browser not open");
-    return id ? svelteDevtools.getComponentDetails(page, id) : svelteDevtools.getComponentTree(page);
+    return inspectSvelteTree(requireCurrentPage(), id);
 }
 export async function viteRestart() {
-    if (!page)
-        throw new Error("browser not open");
-    return page.evaluate(async () => {
+    const currentPage = requireCurrentPage();
+    return currentPage.evaluate(async () => {
         try {
             const response = await fetch("/__vite_restart", { method: "POST" });
             return response.ok ? "restarted" : "restart endpoint not available";
@@ -451,52 +149,22 @@ export async function viteRestart() {
     });
 }
 export async function viteHMR() {
-    if (!page)
-        throw new Error("browser not open");
+    requireCurrentPage();
     return viteHMRTrace("summary", 20);
 }
 export async function viteRuntimeStatus() {
-    if (!page)
-        throw new Error("browser not open");
-    const runtime = await page.evaluate(() => {
-        const findViteClient = () => {
-            const scripts = Array.from(document.querySelectorAll("script[src]"));
-            return scripts.some((script) => script.getAttribute("src")?.includes("/@vite/client"));
-        };
-        const wsStateName = (wsState) => {
-            if (wsState == null)
-                return "unknown";
-            if (wsState === 0)
-                return "connecting";
-            if (wsState === 1)
-                return "open";
-            if (wsState === 2)
-                return "closing";
-            if (wsState === 3)
-                return "closed";
-            return "unknown";
-        };
-        const hot = window.__vite_hot;
-        const ws = hot?.ws || hot?.socket;
-        return {
-            url: location.href,
-            hasViteClient: findViteClient(),
-            wsState: wsStateName(ws?.readyState),
-            hasErrorOverlay: Boolean(document.querySelector("vite-error-overlay")),
-            timestamp: Date.now(),
-        };
-    });
-    return formatRuntimeStatus(runtime, framework, hmrEvents);
+    const currentPage = requireCurrentPage();
+    const runtime = await readRuntimeSnapshot(currentPage);
+    return formatRuntimeStatus(runtime, session.framework, session.hmrEvents);
 }
 export async function viteHMRTrace(mode, limit = 20) {
-    if (!page)
-        throw new Error("browser not open");
+    const currentPage = requireCurrentPage();
     if (mode === "clear") {
-        hmrEvents.length = 0;
+        session.hmrEvents.length = 0;
         return "cleared HMR trace";
     }
-    if (hmrEvents.length === 0) {
-        const fallback = await page.evaluate(() => {
+    if (session.hmrEvents.length === 0) {
+        const fallback = await currentPage.evaluate(() => {
             const updates = window.__vite_hmr_updates || [];
             return updates.slice(-20).map((u) => ({
                 timestamp: u.timestamp ?? Date.now(),
@@ -506,108 +174,53 @@ export async function viteHMRTrace(mode, limit = 20) {
             }));
         });
         if (fallback.length > 0)
-            hmrEvents.push(...fallback);
+            session.hmrEvents.push(...fallback);
     }
-    if (hmrEvents.length === 0)
+    if (session.hmrEvents.length === 0)
         return "No HMR updates";
-    return formatHmrTrace(mode, hmrEvents, limit);
+    return formatHmrTrace(mode, session.hmrEvents, limit);
 }
 export async function viteModuleGraph(filter, limit = 200, mode = "snapshot") {
-    if (!page)
-        throw new Error("browser not open");
+    const currentPage = requireCurrentPage();
     if (mode === "clear") {
-        lastModuleGraphUrls = null;
+        session.lastModuleGraphUrls = null;
         return "cleared module-graph baseline";
     }
-    const moduleRows = await collectModuleRows(page);
+    const moduleRows = await collectModuleRows(currentPage);
     const currentUrls = moduleRows.map((row) => row.url);
-    const previousUrls = lastModuleGraphUrls ? new Set(lastModuleGraphUrls) : null;
-    lastModuleGraphUrls = [...currentUrls];
+    const previousUrls = session.lastModuleGraphUrls ? new Set(session.lastModuleGraphUrls) : null;
+    session.lastModuleGraphUrls = [...currentUrls];
     if (mode === "trace") {
         return formatModuleGraphTrace(currentUrls, previousUrls, filter, limit);
     }
     return formatModuleGraphSnapshot(moduleRows, filter, limit);
 }
-async function collectModuleRows(page) {
-    return page.evaluate(() => {
-        const isLikelyModuleUrl = (url) => {
-            if (!url)
-                return false;
-            if (url.includes("/@vite/"))
-                return true;
-            if (url.includes("/@id/"))
-                return true;
-            if (url.includes("/src/"))
-                return true;
-            if (url.includes("/node_modules/"))
-                return true;
-            return /\.(mjs|cjs|js|jsx|ts|tsx|vue|css)(\?|$)/.test(url);
-        };
-        const scripts = Array.from(document.querySelectorAll("script[src]")).map((node) => node.src);
-        const resources = performance
-            .getEntriesByType("resource")
-            .map((entry) => {
-            const item = entry;
-            return {
-                url: item.name,
-                initiator: item.initiatorType || "unknown",
-                durationMs: Number(item.duration.toFixed(1)),
-            };
-        })
-            .filter((entry) => isLikelyModuleUrl(entry.url));
-        const all = [
-            ...scripts
-                .filter((url) => isLikelyModuleUrl(url))
-                .map((url) => ({ url, initiator: "script-tag", durationMs: 0 })),
-            ...resources,
-        ];
-        const seen = new Set();
-        const unique = [];
-        for (const row of all) {
-            if (seen.has(row.url))
-                continue;
-            seen.add(row.url);
-            unique.push(row);
-        }
-        return unique;
-    });
-}
 export async function errors(mapped = false, inlineSource = false) {
-    if (!page)
-        throw new Error("browser not open");
-    const errorInfo = await page.evaluate(() => {
-        const overlay = document.querySelector("vite-error-overlay");
-        if (!overlay || !overlay.shadowRoot)
-            return null;
-        const message = overlay.shadowRoot.querySelector(".message")?.textContent?.trim();
-        const stack = overlay.shadowRoot.querySelector(".stack")?.textContent?.trim();
-        return { message, stack };
-    });
+    const currentPage = requireCurrentPage();
+    const errorInfo = await readOverlayError(currentPage);
     if (!errorInfo)
         return "no errors";
     const raw = `${errorInfo.message ?? "Vite error"}\n\n${errorInfo.stack ?? ""}`.trim();
     if (!mapped)
         return raw;
-    const origin = new URL(page.url()).origin;
+    const origin = new URL(currentPage.url()).origin;
     const mappedStack = await mapStackTrace(raw, origin, inlineSource);
     return mappedStack;
 }
 export async function logs() {
-    if (consoleLogs.length === 0)
+    if (session.consoleLogs.length === 0)
         return "no logs";
-    return consoleLogs.slice(-50).join("\n");
+    return session.consoleLogs.slice(-50).join("\n");
 }
 export async function screenshot() {
-    if (!page)
-        throw new Error("browser not open");
+    const currentPage = requireCurrentPage();
     const path = join(tmpdir(), `vite-browser-${Date.now()}.png`);
-    await page.screenshot({ path, fullPage: true });
+    await currentPage.screenshot({ path, fullPage: true });
     return path;
 }
 export async function evaluate(script) {
-    if (!page)
-        throw new Error("browser not open");
-    const result = await page.evaluate(script);
+    const currentPage = requireCurrentPage();
+    const result = await currentPage.evaluate(script);
     return JSON.stringify(result, null, 2);
 }
 export async function network(idx) {
@@ -639,3 +252,16 @@ export async function mapStackTrace(stack, origin, inlineSource = false, resolve
         return stack;
     return `${stack}\n\n# Mapped Stack\n${mappedLines.join("\n")}`;
 }
+function requireCurrentPage() {
+    const currentPage = getCurrentPage();
+    if (!currentPage)
+        throw new Error("browser not open");
+    return currentPage;
+}
+async function navigateAndRefreshContext(currentPage, navigate, refreshFramework = false) {
+    await navigate();
+    await injectEventCollector(currentPage);
+    if (refreshFramework) {
+        await detectFramework();
+    }
+}

package/dist/cli.js

@@ -143,6 +143,11 @@ export async function runCli(argv, io) {
         const res = await io.send("correlate-errors", { mapped, inlineSource, windowMs });
         exit(io, res, res.ok && res.data ? String(res.data) : "");
     }
+    if (cmd === "correlate" && arg === "renders") {
+        const windowMs = parseNumberFlag(args, "--window", 5000);
+        const res = await io.send("correlate-renders", { windowMs });
+        exit(io, res, res.ok && res.data ? String(res.data) : "");
+    }
     if (cmd === "diagnose" && arg === "hmr") {
         const mapped = args.includes("--mapped");
         const inlineSource = args.includes("--inline-source");
@@ -151,6 +156,11 @@ export async function runCli(argv, io) {
         const res = await io.send("diagnose-hmr", { mapped, inlineSource, windowMs, limit });
         exit(io, res, res.ok && res.data ? String(res.data) : "");
     }
+    if (cmd === "diagnose" && arg === "propagation") {
+        const windowMs = parseNumberFlag(args, "--window", 5000);
+        const res = await io.send("diagnose-propagation", { windowMs });
+        exit(io, res, res.ok && res.data ? String(res.data) : "");
+    }
     if (cmd === "logs") {
         const res = await io.send("logs");
         exit(io, res, res.ok && res.data ? String(res.data) : "");
@@ -227,9 +237,12 @@ VITE COMMANDS
   errors --mapped                     Show errors with source-map mapping
   errors --mapped --inline-source     Include mapped source snippets
   correlate errors [--window <ms>]    Correlate current errors with recent HMR events
+  correlate renders [--window <ms>]   Summarize recent render/update propagation evidence
   correlate errors --mapped           Correlate mapped errors with recent HMR events
   diagnose hmr [--window <ms>]        Diagnose HMR failures from runtime, errors, and trace data
   diagnose hmr [--limit <n>]          Control how many recent HMR trace entries are inspected
+  diagnose propagation [--window <ms>]
+                                     Diagnose likely update -> render -> error propagation
   logs                                Show dev server logs
 
 UTILITIES