@presto1314w/vite-devtools-browser 0.3.3 → 0.3.6

package/dist/browser-session.d.ts

@@ -20,7 +20,6 @@ export type BrowserSessionState = {
     context: BrowserContext | null;
     page: Page | null;
     framework: BrowserFramework;
-    extensionModeDisabled: boolean;
     collectorInstalled: boolean;
     consoleLogs: string[];
     hmrEvents: HmrEvent[];
@@ -35,3 +34,16 @@ export declare function ensureBrowserPage(state: BrowserSessionState, onPageRead
 export declare function closeBrowserSession(state: BrowserSessionState): Promise<void>;
 export declare function contextUsable(current: Pick<BrowserContext, "pages"> | null): current is Pick<BrowserContext, "pages">;
 export declare function isClosedTargetError(error: unknown): boolean;
+/**
+ * Build platform-aware Chromium launch arguments.
+ *
+ * On Linux (especially Docker / CI without a display server) we add
+ * `--no-sandbox` and `--disable-dev-shm-usage` so that Chromium can
+ * start reliably in headless-shell containers.
+ *
+ * On Windows, `--disable-gpu` is added to work around occasional GPU
+ * process crashes on older drivers.
+ */
+export declare function platformChromiumArgs(extra?: string[]): string[];
+export declare function resolveChromiumExecutablePath(env?: NodeJS.ProcessEnv): string | undefined;
+export declare function resolveBrowserHeadless(env?: NodeJS.ProcessEnv): boolean;

package/dist/browser-session.js

@@ -1,18 +1,12 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
 import { chromium } from "playwright";
-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;
+import { getHookSource } from "./react/hook-manager.js";
+import { isWindows, isLinux } from "./paths.js";
 export function createBrowserSessionState() {
     return {
         context: null,
         page: null,
         framework: "unknown",
-        extensionModeDisabled: false,
         collectorInstalled: false,
         consoleLogs: [],
         hmrEvents: [],
@@ -42,9 +36,7 @@ export function resetBrowserSessionState(state) {
 export async function ensureBrowserPage(state, onPageReady) {
     if (!contextUsable(state.context)) {
         await closeBrowserSession(state);
-        const launched = await launchBrowserContext(state.extensionModeDisabled);
-        state.context = launched.context;
-        state.extensionModeDisabled = launched.extensionModeDisabled;
+        state.context = await launchBrowserContext();
     }
     if (!state.context)
         throw new Error("browser not open");
@@ -56,10 +48,7 @@ export async function ensureBrowserPage(state, onPageReady) {
             if (!isClosedTargetError(error))
                 throw error;
             await closeBrowserSession(state);
-            state.extensionModeDisabled = true;
-            const launched = await launchBrowserContext(state.extensionModeDisabled);
-            state.context = launched.context;
-            state.extensionModeDisabled = launched.extensionModeDisabled;
+            state.context = await launchBrowserContext();
             state.page = state.context.pages()[0] ?? (await state.context.newPage());
         }
         onPageReady(state.page);
@@ -86,32 +75,60 @@ export function isClosedTargetError(error) {
         return false;
     return /Target page, context or browser has been closed/i.test(error.message);
 }
-async function launchBrowserContext(extensionModeDisabled) {
-    if (hasReactExtension && installHook && !extensionModeDisabled) {
-        try {
-            const context = await chromium.launchPersistentContext("", {
-                headless: false,
-                viewport: { width: 1280, height: 720 },
-                args: [
-                    `--disable-extensions-except=${extensionPath}`,
-                    `--load-extension=${extensionPath}`,
-                    "--auto-open-devtools-for-tabs",
-                ],
-            });
-            await context.waitForEvent("serviceworker").catch(() => { });
-            await context.addInitScript(installHook);
-            return { context, extensionModeDisabled };
-        }
-        catch {
-            extensionModeDisabled = true;
-        }
+/**
+ * Build platform-aware Chromium launch arguments.
+ *
+ * On Linux (especially Docker / CI without a display server) we add
+ * `--no-sandbox` and `--disable-dev-shm-usage` so that Chromium can
+ * start reliably in headless-shell containers.
+ *
+ * On Windows, `--disable-gpu` is added to work around occasional GPU
+ * process crashes on older drivers.
+ */
+export function platformChromiumArgs(extra = []) {
+    const args = ["--auto-open-devtools-for-tabs", ...extra];
+    if (isLinux) {
+        args.push("--no-sandbox", "--disable-dev-shm-usage");
     }
+    else if (isWindows) {
+        args.push("--disable-gpu");
+    }
+    return args;
+}
+export function resolveChromiumExecutablePath(env = process.env) {
+    const explicit = env.VITE_BROWSER_EXECUTABLE_PATH || env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH;
+    if (explicit && existsSync(explicit))
+        return explicit;
+    const candidates = isWindows
+        ? [
+            `${env.PROGRAMFILES ?? "C:\\Program Files"}\\Google\\Chrome\\Application\\chrome.exe`,
+            `${env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)"}\\Google\\Chrome\\Application\\chrome.exe`,
+            `${env.LOCALAPPDATA ?? ""}\\Google\\Chrome\\Application\\chrome.exe`,
+        ]
+        : isLinux
+            ? [
+                "/usr/bin/google-chrome",
+                "/usr/bin/chromium",
+                "/usr/bin/chromium-browser",
+                "/snap/bin/chromium",
+            ]
+            : [
+                "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+                "/Applications/Chromium.app/Contents/MacOS/Chromium",
+            ];
+    return candidates.find((candidate) => Boolean(candidate) && existsSync(candidate));
+}
+export function resolveBrowserHeadless(env = process.env) {
+    return /^(1|true|yes)$/i.test(env.VITE_BROWSER_HEADLESS || "");
+}
+async function launchBrowserContext() {
     const browser = await chromium.launch({
-        headless: false,
-        args: ["--auto-open-devtools-for-tabs"],
+        headless: resolveBrowserHeadless(),
+        executablePath: resolveChromiumExecutablePath(),
+        args: platformChromiumArgs(),
     });
-    return {
-        context: await browser.newContext({ viewport: { width: 1280, height: 720 } }),
-        extensionModeDisabled,
-    };
+    const context = await browser.newContext({ viewport: { width: 1280, height: 720 } });
+    // Inject bundled React DevTools hook before any page loads
+    await context.addInitScript(getHookSource());
+    return context;
 }

package/dist/browser.d.ts

@@ -40,6 +40,12 @@ export declare function vueTree(id?: string): Promise<string>;
 export declare function vuePinia(store?: string): Promise<string>;
 export declare function vueRouter(): Promise<string>;
 export declare function reactTree(id?: string): Promise<string>;
+export declare function reactStoreList(): Promise<string>;
+export declare function reactStoreInspect(store: string): Promise<string>;
+export declare function reactHookHealth(): Promise<string>;
+export declare function reactHookInject(): Promise<string>;
+export declare function reactCommits(limit?: number): Promise<string>;
+export declare function reactCommitsClear(): Promise<string>;
 export declare function svelteTree(id?: string): Promise<string>;
 export declare function viteRestart(): Promise<string>;
 export declare function viteHMR(): Promise<string>;

package/dist/browser.js

@@ -5,6 +5,9 @@ import { detectBrowserFramework, inspectReactTree, inspectSvelteTree, inspectVue
 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 { checkHookHealth, formatHookHealth, injectHook } from "./react/hook-manager.js";
+import { clearRenderHistory, formatRenderInfo, getRecentRenders, installRenderTracking } from "./react/profiler.js";
+import { formatStoreInspection, formatStoreList, inspectStore, listStores } from "./react/zustand.js";
 import { resolveViaSourceMap } from "./sourcemap.js";
 export { contextUsable, isClosedTargetError } from "./browser-session.js";
 export { formatHmrTrace, formatModuleGraphSnapshot, formatModuleGraphTrace, formatRuntimeStatus, normalizeLimit, } from "./browser-vite.js";
@@ -189,6 +192,36 @@ export async function vueRouter() {
 export async function reactTree(id) {
     return inspectReactTree(session, requireCurrentPage(), id);
 }
+export async function reactStoreList() {
+    return formatStoreList(await listStores(requireCurrentPage()));
+}
+export async function reactStoreInspect(store) {
+    const result = await inspectStore(requireCurrentPage(), store);
+    if (!result) {
+        throw new Error(`zustand store not found: ${store}`);
+    }
+    return formatStoreInspection(result);
+}
+export async function reactHookHealth() {
+    return formatHookHealth(await checkHookHealth(requireCurrentPage()));
+}
+export async function reactHookInject() {
+    const currentPage = requireCurrentPage();
+    const injected = await injectHook(currentPage);
+    const status = await checkHookHealth(currentPage);
+    const prefix = injected ? "React hook injected.\n\n" : "React hook already installed.\n\n";
+    return `${prefix}${formatHookHealth(status)}`;
+}
+export async function reactCommits(limit = 20) {
+    const currentPage = requireCurrentPage();
+    await installRenderTracking(currentPage);
+    return formatRenderInfo(await getRecentRenders(currentPage, limit));
+}
+export async function reactCommitsClear() {
+    const currentPage = requireCurrentPage();
+    await clearRenderHistory(currentPage);
+    return "cleared React commit history";
+}
 export async function svelteTree(id) {
     return inspectSvelteTree(requireCurrentPage(), id);
 }
@@ -210,6 +243,10 @@ export async function viteHMR() {
 }
 export async function viteRuntimeStatus() {
     const currentPage = requireCurrentPage();
+    if (session.framework === "unknown") {
+        const result = await detectBrowserFramework(currentPage);
+        session.framework = result.framework;
+    }
     const runtime = await readRuntimeSnapshot(currentPage);
     return formatRuntimeStatus(runtime, session.framework, session.hmrEvents);
 }
@@ -334,6 +371,8 @@ async function navigateAndRefreshContext(currentPage, navigate, refreshFramework
     clearRuntimeErrors();
     await injectEventCollector(currentPage);
     if (refreshFramework) {
+        await currentPage.waitForLoadState?.("networkidle", { timeout: 1_000 }).catch(() => { });
+        await currentPage.waitForTimeout?.(100).catch(() => { });
         await detectFramework();
     }
 }

package/dist/cli.js

@@ -97,6 +97,47 @@ export async function runCli(argv, io) {
         const res = await io.send("react-tree", { id });
         exit(io, res, res.ok && res.data ? String(res.data) : "");
     }
+    if (cmd === "react" && arg === "store") {
+        const sub = args[2];
+        if (sub === "list") {
+            const res = await io.send("react-store-list");
+            exit(io, res, res.ok && res.data ? String(res.data) : "");
+        }
+        if (sub === "inspect") {
+            const store = args[3];
+            if (!store) {
+                io.stderr("usage: vite-browser react store inspect <name>");
+                io.exit(1);
+            }
+            const res = await io.send("react-store-inspect", { store });
+            exit(io, res, res.ok && res.data ? String(res.data) : "");
+        }
+        io.stderr("usage: vite-browser react store <list|inspect> [name]");
+        io.exit(1);
+    }
+    if (cmd === "react" && arg === "hook") {
+        const sub = args[2];
+        if (sub === "health") {
+            const res = await io.send("react-hook-health");
+            exit(io, res, res.ok && res.data ? String(res.data) : "");
+        }
+        if (sub === "inject") {
+            const res = await io.send("react-hook-inject");
+            exit(io, res, res.ok && res.data ? String(res.data) : "");
+        }
+        io.stderr("usage: vite-browser react hook <health|inject>");
+        io.exit(1);
+    }
+    if (cmd === "react" && arg === "commits") {
+        const sub = args[2];
+        if (sub === "clear") {
+            const res = await io.send("react-commits-clear");
+            exit(io, res, res.ok && res.data ? String(res.data) : "cleared React commit history");
+        }
+        const limit = parseNumberFlag(args, "--limit", 20);
+        const res = await io.send("react-commits", { limit });
+        exit(io, res, res.ok && res.data ? String(res.data) : "");
+    }
     if (cmd === "svelte" && arg === "tree") {
         const id = args[2];
         const res = await io.send("svelte-tree", { id });
@@ -205,63 +246,69 @@ export function exit(io, res, msg) {
     io.exit(0);
 }
 export function printUsage() {
-    return `
-vite-browser - Programmatic access to Vue/React/Svelte DevTools and Vite dev server
-
-USAGE
-  vite-browser <command> [options]
-
-BROWSER CONTROL
-  open <url> [--cookies-json <file>]  Launch browser and navigate
-  close                               Close browser and daemon
-  goto <url>                          Full-page navigation
-  back                                Go back in history
-  reload                              Reload current page
-
-FRAMEWORK DETECTION
-  detect                              Detect framework (vue/react/svelte)
-
-VUE COMMANDS
-  vue tree [id]                       Show Vue component tree or inspect component
-  vue pinia [store]                   Show Pinia stores or inspect specific store
-  vue router                          Show Vue Router information
-
-REACT COMMANDS
-  react tree [id]                     Show React component tree or inspect component
-
-SVELTE COMMANDS
-  svelte tree [id]                    Show Svelte component tree or inspect component
-
-VITE COMMANDS
-  vite restart                        Restart Vite dev server
-  vite hmr                            Show HMR summary
-  vite hmr trace [--limit <n>]        Show HMR timeline
-  vite hmr clear                      Clear tracked HMR timeline
-  vite runtime                        Show Vite runtime status
-  vite module-graph [--filter <txt>] [--limit <n>]
-                                     Show loaded Vite module resources
-  vite module-graph trace [--filter <txt>] [--limit <n>]
-                                     Show module additions/removals since baseline
-  vite module-graph clear             Clear module-graph baseline
-  errors                              Show build/runtime errors
-  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
-  screenshot                          Save screenshot to temp file
-  eval <script>                       Evaluate JavaScript in page context
-  network [idx]                       List network requests or inspect one
-
-OPTIONS
-  -h, --help                          Show this help message
+    return `
+vite-browser - Programmatic access to Vue/React/Svelte DevTools and Vite dev server
+
+USAGE
+  vite-browser <command> [options]
+
+BROWSER CONTROL
+  open <url> [--cookies-json <file>]  Launch browser and navigate
+  close                               Close browser and daemon
+  goto <url>                          Full-page navigation
+  back                                Go back in history
+  reload                              Reload current page
+
+FRAMEWORK DETECTION
+  detect                              Detect framework (vue/react/svelte)
+
+VUE COMMANDS
+  vue tree [id]                       Show Vue component tree or inspect component
+  vue pinia [store]                   Show Pinia stores or inspect specific store
+  vue router                          Show Vue Router information
+
+REACT COMMANDS
+  react tree [id]                     Show React component tree or inspect component
+  react store list                    List detected Zustand stores
+  react store inspect <name>          Show Zustand store state and actions
+  react hook health                   Show bundled React hook status
+  react hook inject                   Inject bundled React hook into current page
+  react commits [--limit <n>]         Show recent React commit records
+  react commits clear                 Clear recorded React commit history
+
+SVELTE COMMANDS
+  svelte tree [id]                    Show Svelte component tree or inspect component
+
+VITE COMMANDS
+  vite restart                        Restart Vite dev server
+  vite hmr                            Show HMR summary
+  vite hmr trace [--limit <n>]        Show HMR timeline
+  vite hmr clear                      Clear tracked HMR timeline
+  vite runtime                        Show Vite runtime status
+  vite module-graph [--filter <txt>] [--limit <n>]
+                                     Show loaded Vite module resources
+  vite module-graph trace [--filter <txt>] [--limit <n>]
+                                     Show module additions/removals since baseline
+  vite module-graph clear             Clear module-graph baseline
+  errors                              Show build/runtime errors
+  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
+  screenshot                          Save screenshot to temp file
+  eval <script>                       Evaluate JavaScript in page context
+  network [idx]                       List network requests or inspect one
+
+OPTIONS
+  -h, --help                          Show this help message
 `;
 }
 function isEntrypoint(argv1) {

package/dist/client.js

@@ -3,7 +3,7 @@ import { readFileSync, existsSync, rmSync } from "node:fs";
 import { spawn } from "node:child_process";
 import { setTimeout as sleep } from "node:timers/promises";
 import { fileURLToPath } from "node:url";
-import { socketPath, pidFile } from "./paths.js";
+import { socketPath, pidFile, isWindows } from "./paths.js";
 export function createClientDeps() {
     const ext = import.meta.url.endsWith(".ts") ? ".ts" : ".js";
     const daemonPath = fileURLToPath(new URL(`./daemon${ext}`, import.meta.url));
@@ -86,7 +86,7 @@ export function no() {
     return false;
 }
 export function removeSocketFile(path, removeFile = rmSync) {
-    if (process.platform === "win32")
+    if (isWindows)
         return;
     removeFile(path, { force: true });
 }

package/dist/daemon.js

@@ -8,6 +8,7 @@ import { diagnoseHMR, formatDiagnosisReport } from "./diagnose.js";
 import { diagnosePropagation, formatPropagationDiagnosisReport } from "./diagnose-propagation.js";
 import { extractModules } from "./event-analysis.js";
 import { socketDir, socketPath, pidFile } from "./paths.js";
+import { removeSocketFile } from "./client.js";
 import { correlateRenderPropagation, formatPropagationTraceReport } from "./trace.js";
 import { EventQueue } from "./event-queue.js";
 import * as networkLog from "./network.js";
@@ -70,6 +71,30 @@ export function createRunner(api = browser) {
             const data = await api.reactTree(cmd.id);
             return { ok: true, data };
         }
+        if (cmd.action === "react-store-list") {
+            const data = await api.reactStoreList();
+            return { ok: true, data };
+        }
+        if (cmd.action === "react-store-inspect") {
+            const data = await api.reactStoreInspect(cmd.store);
+            return { ok: true, data };
+        }
+        if (cmd.action === "react-hook-health") {
+            const data = await api.reactHookHealth();
+            return { ok: true, data };
+        }
+        if (cmd.action === "react-hook-inject") {
+            const data = await api.reactHookInject();
+            return { ok: true, data };
+        }
+        if (cmd.action === "react-commits") {
+            const data = await api.reactCommits(cmd.limit ?? 20);
+            return { ok: true, data };
+        }
+        if (cmd.action === "react-commits-clear") {
+            const data = await api.reactCommitsClear();
+            return { ok: true, data };
+        }
         // Svelte commands
         if (cmd.action === "svelte-tree") {
             const data = await api.svelteTree(cmd.id);
@@ -303,7 +328,7 @@ export function startDaemon() {
     networkLog.setEventQueue(eventQueue);
     const run = createRunner();
     mkdirSync(socketDir, { recursive: true, mode: 0o700 });
-    removeSocketFile();
+    removeSocketFile(socketPath);
     rmSync(pidFile, { force: true });
     writeFileSync(pidFile, String(process.pid));
     const server = createServer((socket) => {
@@ -330,16 +355,10 @@ export function startDaemon() {
         process.exit(0);
     }
     function cleanup() {
-        removeSocketFile();
+        removeSocketFile(socketPath);
         rmSync(pidFile, { force: true });
     }
 }
-function removeSocketFile() {
-    // Windows named pipes are not filesystem entries, so unlinking them fails with EPERM.
-    if (process.platform === "win32")
-        return;
-    rmSync(socketPath, { force: true });
-}
 if (process.argv[1] && fileURLToPath(import.meta.url) === process.argv[1]) {
     startDaemon();
 }

package/dist/event-queue.d.ts

@@ -74,8 +74,15 @@ export declare class EventQueue {
     private readonly maxSize;
     constructor(maxSize?: number);
     push(event: VBEvent): void;
+    /** Bubble the element at `idx` leftward to restore sorted order. */
+    private _insertionSort;
     /**
-     * Return all events within the last `ms` milliseconds before `before`
+     * Return all events within the last `ms` milliseconds before `before`.
+     *
+     * Uses binary search to find the start index (O(log n)) then slices,
+     * which is significantly faster than a full linear scan for large queues.
+     * Events are maintained in insertion order, which for timestamped pushes
+     * is monotonically non-decreasing.
      */
     window(ms: number, before?: number): VBEvent[];
     /**
@@ -83,5 +90,7 @@ export declare class EventQueue {
      */
     ofType(type: VBEventType): VBEvent[];
     all(): VBEvent[];
+    /** Number of events currently stored */
+    get size(): number;
     clear(): void;
 }

package/dist/event-queue.js

@@ -9,13 +9,59 @@ export class EventQueue {
         if (this.events.length > this.maxSize) {
             this.events.shift();
         }
+        // Maintain sorted order by timestamp.  Events almost always arrive
+        // in order, so the fast path (no swap) costs a single comparison.
+        const len = this.events.length;
+        if (len >= 2 && this.events[len - 1].timestamp < this.events[len - 2].timestamp) {
+            this._insertionSort(len - 1);
+        }
+    }
+    /** Bubble the element at `idx` leftward to restore sorted order. */
+    _insertionSort(idx) {
+        const events = this.events;
+        const item = events[idx];
+        let j = idx - 1;
+        while (j >= 0 && events[j].timestamp > item.timestamp) {
+            events[j + 1] = events[j];
+            j--;
+        }
+        events[j + 1] = item;
     }
     /**
-     * Return all events within the last `ms` milliseconds before `before`
+     * Return all events within the last `ms` milliseconds before `before`.
+     *
+     * Uses binary search to find the start index (O(log n)) then slices,
+     * which is significantly faster than a full linear scan for large queues.
+     * Events are maintained in insertion order, which for timestamped pushes
+     * is monotonically non-decreasing.
      */
     window(ms, before = Date.now()) {
         const start = before - ms;
-        return this.events.filter((e) => e.timestamp >= start && e.timestamp <= before);
+        const events = this.events;
+        const len = events.length;
+        if (len === 0)
+            return [];
+        // Binary search for the first event with timestamp >= start
+        let lo = 0;
+        let hi = len;
+        while (lo < hi) {
+            const mid = (lo + hi) >>> 1;
+            if (events[mid].timestamp < start) {
+                lo = mid + 1;
+            }
+            else {
+                hi = mid;
+            }
+        }
+        // Linear scan from lo for events <= before
+        // (in practice, `before` is usually Date.now() so most events qualify)
+        const result = [];
+        for (let i = lo; i < len; i++) {
+            if (events[i].timestamp > before)
+                break;
+            result.push(events[i]);
+        }
+        return result;
     }
     /**
      * Return all events of a given type
@@ -26,6 +72,10 @@ export class EventQueue {
     all() {
         return [...this.events];
     }
+    /** Number of events currently stored */
+    get size() {
+        return this.events.length;
+    }
     clear() {
         this.events = [];
     }

package/dist/paths.d.ts

@@ -1,3 +1,28 @@
+export declare const isWindows: boolean;
+export declare const isLinux: boolean;
+/**
+ * Sanitize a session name for safe use in file paths and pipe names.
+ */
+export declare function sanitizeSession(name: string): string;
+/**
+ * Resolve the base directory for vite-browser runtime files.
+ *
+ * Uses `~/.vite-browser` on all platforms.
+ * Falls back to `$TMPDIR/vite-browser-<uid>` when the home directory
+ * is not writable (e.g. some CI/container environments).
+ */
+export declare function resolveSocketDir(): string;
 export declare const socketDir: string;
+/**
+ * Socket path for the daemon.
+ *
+ * - Windows: uses a named pipe `\\.\pipe\vite-browser-<session>`
+ * - Unix: uses a Unix domain socket file in socketDir
+ *
+ * Note: Unix socket paths have a ~104-char limit on macOS and ~108 on
+ * Linux.  The `~/.vite-browser/<session>.sock` path is well within
+ * that range.  The tmpdir fallback may produce longer paths; we keep
+ * them short by using numeric uid.
+ */
 export declare const socketPath: string;
 export declare const pidFile: string;