@presto1314w/vite-devtools-browser 0.2.2 → 0.3.1

package/dist/browser.js

@@ -1,29 +1,18 @@
-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;
+const MAX_RUNTIME_ERRORS = 50;
 export function setEventQueue(queue) {
     eventQueue = queue;
 }
@@ -31,84 +20,23 @@ 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 }
-            });
-        });
-    });
+    if (session.context && !session.collectorInstalled) {
+        await session.context.addInitScript(initBrowserEventCollector);
+        session.collectorInstalled = true;
+    }
+    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 +44,36 @@ 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());
+        const type = msg.type();
+        const message = msg.text();
+        recordConsoleMessage(session.consoleLogs, session.hmrEvents, type, message);
+        if (type === "error" || isVueUnhandledWarning(type, message)) {
+            recordRuntimeError(session.runtimeErrors, message, undefined, undefined, undefined, undefined);
+        }
+    });
+    currentPage.on("pageerror", (error) => {
+        recordRuntimeError(session.runtimeErrors, error.message, error.stack, undefined, undefined, undefined, "pageerror");
     });
 }
 export function recordConsoleMessage(logs, events, type, message, maxLogs = MAX_LOGS, maxEvents = MAX_HMR_EVENTS) {
@@ -221,6 +88,34 @@ export function recordConsoleMessage(logs, events, type, message, maxLogs = MAX_
     if (events.length > maxEvents)
         events.shift();
 }
+export function recordRuntimeError(runtimeErrors, message, stack, source, line, col, logType = "runtime-error", maxErrors = MAX_RUNTIME_ERRORS) {
+    const error = {
+        timestamp: Date.now(),
+        message,
+        stack,
+        source,
+        line,
+        col,
+    };
+    runtimeErrors.push(error);
+    if (runtimeErrors.length > maxErrors)
+        runtimeErrors.shift();
+    eventQueue?.push({
+        timestamp: error.timestamp,
+        type: "error",
+        payload: {
+            message,
+            stack,
+            source,
+            line,
+            col,
+        },
+    });
+    const details = stack ? `${message}\n${stack}` : message;
+    session.consoleLogs.push(`[${logType}] ${details}`);
+    if (session.consoleLogs.length > MAX_LOGS)
+        session.consoleLogs.shift();
+}
 export function parseViteLog(message) {
     const lower = message.toLowerCase();
     const event = {
@@ -247,108 +142,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 +153,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 +190,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 +215,67 @@ 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 };
-    });
-    if (!errorInfo)
+    const currentPage = requireCurrentPage();
+    const errorInfo = await readOverlayError(currentPage);
+    const runtimeError = session.runtimeErrors[session.runtimeErrors.length - 1];
+    if (!errorInfo && !runtimeError)
         return "no errors";
-    const raw = `${errorInfo.message ?? "Vite error"}\n\n${errorInfo.stack ?? ""}`.trim();
+    const raw = errorInfo
+        ? `${errorInfo.message ?? "Vite error"}\n\n${errorInfo.stack ?? ""}`.trim()
+        : formatRuntimeError(runtimeError);
     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;
 }
+function formatRuntimeError(error) {
+    const location = error.source && error.line != null && error.col != null
+        ? `\n\nat ${error.source}:${error.line}:${error.col}`
+        : "";
+    return `${error.message}${location}${error.stack ? `\n\n${error.stack}` : ""}`.trim();
+}
+function isVueUnhandledWarning(type, message) {
+    if (type !== "warning")
+        return false;
+    return /\[Vue warn\]: Unhandled error during execution/i.test(message);
+}
 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 +307,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();
+    }
+}