@xiaou66/vite-plugin-vue-mcp-next 1.0.4 → 1.1.0

package/dist/index.js

@@ -18,6 +18,11 @@ var DEFAULT_MASK_HEADERS = [
 var DEFAULT_MCP_PATH = "/__mcp";
 var DEFAULT_SCREENSHOT_MAX_BYTES = 5 * 1024 * 1024;
 var DEFAULT_SCREENSHOT_SAVE_DIR = ".vite-mcp/screenshot";
+var DEFAULT_PERFORMANCE_SAVE_DIR = ".vite-mcp/performance";
+var DEFAULT_PERFORMANCE_MAX_REPORTS = 100;
+var DEFAULT_PERFORMANCE_MAX_DURATION_MS = 3e4;
+var DEFAULT_PERFORMANCE_SAMPLE_INTERVAL_MS = 250;
+var DEFAULT_PERFORMANCE_LONG_TASK_THRESHOLD_MS = 50;
 var MCP_TOOL_NAMES = {
   listPages: "list_pages",
   reloadPage: "reload_page",
@@ -30,6 +35,11 @@ var MCP_TOOL_NAMES = {
   getNetworkRequests: "get_network_requests",
   getNetworkRequestDetail: "get_network_request_detail",
   clearNetworkRequests: "clear_network_requests",
+  recordPerformance: "record_performance",
+  startPerformanceRecording: "start_performance_recording",
+  stopPerformanceRecording: "stop_performance_recording",
+  getPerformanceReport: "get_performance_report",
+  takeHeapSnapshot: "take_heap_snapshot",
   getComponentTree: "get_component_tree",
   getComponentState: "get_component_state",
   editComponentState: "edit_component_state",
@@ -98,6 +108,19 @@ var DEFAULT_OPTIONS = {
       options: {},
       plugins: []
     }
+  },
+  performance: {
+    mode: "auto",
+    maxDurationMs: DEFAULT_PERFORMANCE_MAX_DURATION_MS,
+    sampleIntervalMs: DEFAULT_PERFORMANCE_SAMPLE_INTERVAL_MS,
+    longTaskThresholdMs: DEFAULT_PERFORMANCE_LONG_TASK_THRESHOLD_MS,
+    saveDir: DEFAULT_PERFORMANCE_SAVE_DIR,
+    memory: {
+      enabled: true
+    },
+    stacks: {
+      enabled: true
+    }
   }
 };
 function mergeMcpClientOptions(cursorConfig, mcpClients) {
@@ -167,6 +190,18 @@ function mergeOptions(options = {}) {
           ...DEFAULT_OPTIONS.screenshot.snapdom.plugins
         ]
       }
+    },
+    performance: {
+      ...DEFAULT_OPTIONS.performance,
+      ...options.performance,
+      memory: {
+        ...DEFAULT_OPTIONS.performance.memory,
+        ...options.performance?.memory
+      },
+      stacks: {
+        ...DEFAULT_OPTIONS.performance.stacks,
+        ...options.performance?.stacks
+      }
     }
   };
 }
@@ -262,7 +297,11 @@ function createVueMcpNextContext(options) {
     rpcServer: void 0,
     pages: createPageTargetRegistry(),
     consoleRecords: createRingBuffer(options.console.maxRecords),
-    networkRecords: createRingBuffer(options.network.maxRecords)
+    networkRecords: createRingBuffer(options.network.maxRecords),
+    performanceReports: createRingBuffer(
+      DEFAULT_PERFORMANCE_MAX_REPORTS
+    ),
+    performanceSessions: /* @__PURE__ */ new Map()
   };
 }
 
@@ -380,13 +419,13 @@ async function requestRuntimeData(ctx, trigger) {
     return { ok: false, error: "runtime bridge is not connected" };
   }
   const event = nanoid();
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const timeout = setTimeout(() => {
-      resolve({ ok: false, error: "runtime bridge response timed out" });
+      resolve2({ ok: false, error: "runtime bridge response timed out" });
     }, 5e3);
     ctx.hooks.hookOnce(event, (data) => {
       clearTimeout(timeout);
-      resolve(data);
+      resolve2(data);
     });
     trigger(event);
   });
@@ -665,9 +704,595 @@ function registerNetworkTools(server, ctx) {
   );
 }
 
-// src/mcp/tools/pages.ts
+// src/mcp/tools/performance.ts
 import { z as z5 } from "zod";
 
+// src/performance/summary.ts
+function buildPerformanceSummary(input) {
+  const memory = buildMemorySummary(input.memorySamples);
+  const blockedTimeMs = input.longTasks.reduce((total, task) => {
+    return total + Math.max(0, task.durationMs - DEFAULT_PERFORMANCE_LONG_TASK_THRESHOLD_MS);
+  }, 0);
+  const longTaskCount = input.longTasks.length;
+  const durations = input.longTasks.map((task) => task.durationMs);
+  const maxTaskDurationMs = durations.length ? Math.max(...durations) : 0;
+  const averageTaskDurationMs = durations.length ? Math.round(
+    durations.reduce((total, duration) => total + duration, 0) / durations.length
+  ) : void 0;
+  const suspectedJank = blockedTimeMs > 0 || memory.trend === "growing" || longTaskCount > 0;
+  const severity = resolveSeverity({
+    blockedTimeMs,
+    longTaskCount,
+    memoryTrend: memory.trend
+  });
+  return {
+    blockedTimeMs,
+    longTaskCount,
+    maxTaskDurationMs,
+    averageTaskDurationMs,
+    suspectedJank,
+    severity
+  };
+}
+function buildMemorySummary(samples) {
+  const first = samples[0]?.usedJSHeapSize;
+  const last = samples.at(-1)?.usedJSHeapSize;
+  const peak = samples.reduce((currentPeak, sample) => {
+    if (typeof sample.usedJSHeapSize !== "number") {
+      return currentPeak;
+    }
+    return Math.max(currentPeak, sample.usedJSHeapSize);
+  }, 0);
+  const trend = resolveMemoryTrend(first, last);
+  return {
+    samples,
+    initialUsedJSHeapSize: first,
+    finalUsedJSHeapSize: last,
+    peakUsedJSHeapSize: peak || void 0,
+    deltaUsedJSHeapSize: typeof first === "number" && typeof last === "number" ? last - first : void 0,
+    trend
+  };
+}
+function buildStackSummary(frames, options = {}) {
+  return {
+    topFrames: [...frames].sort(sortByHotness).slice(0, 10),
+    rawProfilePath: options.rawProfilePath,
+    limitation: options.limitation
+  };
+}
+function resolveSeverity(input) {
+  if (input.blockedTimeMs >= 1e3 || input.longTaskCount >= 10) {
+    return "critical";
+  }
+  if (input.blockedTimeMs > 0 || input.memoryTrend === "growing") {
+    return "warning";
+  }
+  return "ok";
+}
+function resolveMemoryTrend(first, last) {
+  if (typeof first !== "number" || typeof last !== "number") {
+    return "unknown";
+  }
+  if (last > first) {
+    return "growing";
+  }
+  return "stable";
+}
+function sortByHotness(left, right) {
+  return compareNumber(right.totalTimeMs, left.totalTimeMs) || compareNumber(right.selfTimeMs, left.selfTimeMs) || compareNumber(right.hitCount, left.hitCount);
+}
+function compareNumber(left, right) {
+  return (left ?? -1) - (right ?? -1);
+}
+
+// src/performance/output.ts
+import { mkdir, writeFile } from "fs/promises";
+import { relative, resolve } from "path";
+import { nanoid as nanoid2 } from "nanoid";
+async function writePerformanceArtifact(options) {
+  const root = resolve(options.root ?? process.cwd());
+  const dir = resolveOutputDirectory(root, options.saveDir);
+  const path8 = resolve(dir, createSafeFileName(options.fileName));
+  const data = typeof options.data === "string" ? Buffer.from(options.data) : options.data;
+  await mkdir(dir, { recursive: true });
+  await writeFile(path8, data);
+  return {
+    kind: options.kind,
+    path: path8,
+    relativePath: relative(root, path8),
+    byteLength: data.byteLength,
+    source: "cdp"
+  };
+}
+function resolveOutputDirectory(root, saveDir) {
+  return resolve(root, saveDir);
+}
+function createSafeFileName(fileName) {
+  const trimmed = fileName.trim();
+  if (!trimmed) {
+    return `${String(Date.now())}-${nanoid2()}`;
+  }
+  const suffix = nanoid2(6);
+  const dotIndex = trimmed.lastIndexOf(".");
+  if (dotIndex === -1) {
+    return `${trimmed}-${suffix}`;
+  }
+  const base = trimmed.slice(0, dotIndex);
+  const extension = trimmed.slice(dotIndex);
+  return `${base}-${suffix}${extension}`;
+}
+
+// src/cdp/cdpPerformance.ts
+async function recordCdpPerformance(options) {
+  const session = await startCdpPerformanceRecording(options);
+  await waitForDuration(options.durationMs);
+  return stopCdpPerformanceRecording({
+    client: options.client,
+    session
+  });
+}
+async function startCdpPerformanceRecording(options) {
+  await options.client.Performance.enable();
+  await options.client.Profiler.enable();
+  await options.client.Profiler.start();
+  return {
+    recordingId: createRecordingId(options.pageId),
+    pageId: options.pageId,
+    startedAt: Date.now(),
+    includeMemory: options.includeMemory,
+    includeStacks: options.includeStacks,
+    saveDir: options.saveDir
+  };
+}
+async function stopCdpPerformanceRecording(options) {
+  const endedAt = Date.now();
+  const [metricsResult, profileResult] = await Promise.all([
+    options.client.Performance.getMetrics(),
+    options.client.Profiler.stop()
+  ]);
+  const metrics = toMetricMap(metricsResult.metrics);
+  const longTasks = toLongTaskRecords(metrics);
+  const memorySamples = options.session.includeMemory ? [toMemorySample(metrics)] : [];
+  const memory = options.session.includeMemory ? buildMemorySummary(memorySamples) : void 0;
+  const stacks = options.session.includeStacks ? buildStackSummary(aggregateCpuProfile(profileResult.profile)) : void 0;
+  const artifact = await writeCpuProfileArtifact(
+    {
+      pageId: options.session.pageId,
+      saveDir: options.session.saveDir
+    },
+    profileResult.profile
+  );
+  const report = {
+    recordingId: options.session.recordingId,
+    pageId: options.session.pageId,
+    source: "cdp",
+    startedAt: options.session.startedAt,
+    endedAt,
+    durationMs: endedAt - options.session.startedAt,
+    summary: buildPerformanceSummary({
+      longTasks,
+      memorySamples
+    }),
+    longTasks,
+    memory,
+    stacks,
+    artifacts: [artifact],
+    limitations: [
+      "CDP path returns sampled CPU profile data, not a full instruction trace"
+    ]
+  };
+  return report;
+}
+async function takeHeapSnapshot(options) {
+  const chunks = [];
+  await options.client.HeapProfiler.enable();
+  options.client.HeapProfiler.addHeapSnapshotChunk((event) => {
+    const payload = event;
+    if (payload.chunk) {
+      chunks.push(payload.chunk);
+    }
+  });
+  await options.client.HeapProfiler.takeHeapSnapshot({
+    reportProgress: false
+  });
+  const artifact = await writePerformanceArtifact({
+    root: process.cwd(),
+    saveDir: options.saveDir,
+    fileName: `${options.pageId}-heap-snapshot.heapsnapshot`,
+    kind: "heap-snapshot",
+    data: Buffer.from(chunks.join(""))
+  });
+  return artifact;
+}
+function createRecordingId(pageId) {
+  return `cdp-${pageId}-${String(Date.now())}`;
+}
+function waitForDuration(durationMs) {
+  return new Promise((resolve2) => {
+    setTimeout(() => {
+      resolve2();
+    }, durationMs);
+  });
+}
+function toMetricMap(metrics) {
+  return new Map(metrics.map((metric) => [metric.name, metric.value]));
+}
+function toLongTaskRecords(metrics) {
+  const taskDuration = metrics.get("TaskDuration") ?? 0;
+  if (taskDuration <= 0) {
+    return [];
+  }
+  return [
+    {
+      startTime: 0,
+      durationMs: taskDuration,
+      name: "TaskDuration",
+      source: "cpu-profile"
+    }
+  ];
+}
+function toMemorySample(metrics) {
+  return {
+    timestamp: Date.now(),
+    usedJSHeapSize: metrics.get("JSHeapUsedSize"),
+    totalJSHeapSize: metrics.get("JSHeapTotalSize"),
+    jsHeapSizeLimit: metrics.get("JSHeapSizeLimit")
+  };
+}
+function aggregateCpuProfile(profile) {
+  const nodes = profile.nodes ?? [];
+  const nodeMap = /* @__PURE__ */ new Map();
+  const nodeIndex = /* @__PURE__ */ new Map();
+  nodes.forEach((node) => nodeIndex.set(node.id, node));
+  (profile.samples ?? []).forEach((nodeId, index) => {
+    const node = nodeIndex.get(nodeId);
+    if (!node) {
+      return;
+    }
+    const delta = profile.timeDeltas?.[index] ?? 0;
+    const current = nodeMap.get(nodeId) ?? {
+      functionName: node.callFrame.functionName || "<anonymous>",
+      url: node.callFrame.url,
+      lineNumber: node.callFrame.lineNumber,
+      columnNumber: node.callFrame.columnNumber,
+      selfTimeMs: 0,
+      totalTimeMs: 0,
+      hitCount: 0
+    };
+    nodeMap.set(nodeId, {
+      ...current,
+      selfTimeMs: current.selfTimeMs + delta,
+      totalTimeMs: current.totalTimeMs + delta,
+      hitCount: current.hitCount + 1
+    });
+  });
+  return [...nodeMap.values()];
+}
+async function writeCpuProfileArtifact(options, profile) {
+  return writePerformanceArtifact({
+    root: process.cwd(),
+    saveDir: options.saveDir ?? ".vite-mcp/performance",
+    fileName: `${options.pageId}-cpu-profile.cpuprofile`,
+    kind: "cpu-profile",
+    data: Buffer.from(JSON.stringify(profile, null, 2))
+  });
+}
+
+// src/mcp/tools/performance.ts
+var PERFORMANCE_NOT_AVAILABLE_ERROR = "Performance diagnostics are disabled by configuration";
+var activeCdpPerformanceClients = /* @__PURE__ */ new Map();
+function registerPerformanceTools(server, ctx) {
+  server.registerTool(
+    MCP_TOOL_NAMES.recordPerformance,
+    {
+      description: "Record a performance sample for the selected page.",
+      inputSchema: {
+        pageId: z5.string().optional(),
+        durationMs: z5.number().optional(),
+        includeMemory: z5.boolean().optional(),
+        includeStacks: z5.boolean().optional()
+      }
+    },
+    async (input) => handleRecordPerformance(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.startPerformanceRecording,
+    {
+      description: "Start a performance recording session.",
+      inputSchema: {
+        pageId: z5.string().optional(),
+        includeMemory: z5.boolean().optional(),
+        includeStacks: z5.boolean().optional()
+      }
+    },
+    async (input) => handleStartPerformanceRecording(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.stopPerformanceRecording,
+    {
+      description: "Stop a performance recording session.",
+      inputSchema: {
+        recordingId: z5.string()
+      }
+    },
+    async (input) => handleStopPerformanceRecording(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getPerformanceReport,
+    {
+      description: "Get cached performance reports and active sessions.",
+      inputSchema: {
+        pageId: z5.string().optional(),
+        recordingId: z5.string().optional(),
+        limit: z5.number().optional()
+      }
+    },
+    (input) => handleGetPerformanceReport(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.takeHeapSnapshot,
+    {
+      description: "Take a heap snapshot with CDP.",
+      inputSchema: {
+        pageId: z5.string().optional()
+      }
+    },
+    async (input) => handleTakeHeapSnapshot(ctx, input)
+  );
+}
+function appendPerformanceReport(ctx, report) {
+  if (ctx.performanceReports.all().some((item) => item.recordingId === report.recordingId)) {
+    return;
+  }
+  ctx.performanceReports.push(report);
+}
+async function handleRecordPerformance(ctx, input) {
+  const durationMs = input.durationMs ?? ctx.options.performance.maxDurationMs;
+  const includeMemory = input.includeMemory ?? ctx.options.performance.memory.enabled;
+  const includeStacks = input.includeStacks ?? ctx.options.performance.stacks.enabled;
+  if (ctx.options.performance.mode === "off") {
+    return createToolError(PERFORMANCE_NOT_AVAILABLE_ERROR);
+  }
+  if (ctx.options.performance.mode !== "hook") {
+    const cdpResult = await connectPerformanceCdp(ctx, input.pageId);
+    const cdp = cdpResult.cdp;
+    if (cdp) {
+      try {
+        const report = await recordCdpPerformance({
+          client: cdp.client,
+          pageId: input.pageId ?? "cdp",
+          durationMs,
+          includeMemory,
+          includeStacks,
+          saveDir: ctx.options.performance.saveDir
+        });
+        appendPerformanceReport(ctx, report);
+        return createToolResponse(toStructuredRecord(report));
+      } finally {
+        await closeCdpClient(cdp.client);
+      }
+    }
+    if (ctx.options.performance.mode === "cdp") {
+      return createToolError(
+        formatCdpUnavailableError(
+          "CDP performance collection is unavailable",
+          cdpResult.error
+        )
+      );
+    }
+  }
+  const result = await requestRuntimeData(ctx, (event) => {
+    void ctx.rpcServer?.recordPerformance({
+      event,
+      durationMs,
+      includeMemory,
+      includeStacks
+    });
+  });
+  if (isPerformanceReport(result)) {
+    appendPerformanceReport(ctx, result);
+  }
+  if (isPlainRecord(result)) {
+    return createToolResponse(toStructuredRecord(result));
+  }
+  return createToolError("runtime bridge returned an invalid response");
+}
+async function handleStartPerformanceRecording(ctx, input) {
+  const includeMemory = input.includeMemory ?? ctx.options.performance.memory.enabled;
+  const includeStacks = input.includeStacks ?? ctx.options.performance.stacks.enabled;
+  if (ctx.options.performance.mode === "off") {
+    return createToolError(PERFORMANCE_NOT_AVAILABLE_ERROR);
+  }
+  if (ctx.options.performance.mode !== "hook") {
+    const cdpResult = await connectPerformanceCdp(ctx, input.pageId);
+    const cdp = cdpResult.cdp;
+    if (cdp) {
+      try {
+        const session = await startCdpPerformanceRecording({
+          client: cdp.client,
+          pageId: input.pageId ?? "cdp",
+          includeMemory,
+          includeStacks,
+          saveDir: ctx.options.performance.saveDir
+        });
+        ctx.performanceSessions.set(session.recordingId, {
+          recordingId: session.recordingId,
+          pageId: session.pageId,
+          source: "cdp",
+          startedAt: session.startedAt,
+          includeMemory,
+          includeStacks,
+          mode: ctx.options.performance.mode
+        });
+        activeCdpPerformanceClients.set(session.recordingId, cdp.client);
+        return createToolResponse(
+          toStructuredRecord({
+            ...session,
+            source: "cdp"
+          })
+        );
+      } catch (error) {
+        await closeCdpClient(cdp.client);
+        return createToolError(
+          error instanceof Error ? error.message : String(error)
+        );
+      }
+    }
+    if (ctx.options.performance.mode === "cdp") {
+      return createToolError(
+        formatCdpUnavailableError(
+          "CDP performance collection is unavailable",
+          cdpResult.error
+        )
+      );
+    }
+  }
+  const result = await requestRuntimeData(ctx, (event) => {
+    void ctx.rpcServer?.startPerformanceRecording({
+      event,
+      includeMemory,
+      includeStacks
+    });
+  });
+  if (isPerformanceStartResult(result)) {
+    ctx.performanceSessions.set(result.recordingId, {
+      recordingId: result.recordingId,
+      pageId: input.pageId ?? "runtime",
+      source: "hook",
+      startedAt: result.startedAt,
+      includeMemory,
+      includeStacks,
+      mode: ctx.options.performance.mode
+    });
+  }
+  if (isPlainRecord(result)) {
+    return createToolResponse(toStructuredRecord(result));
+  }
+  return createToolError("runtime bridge returned an invalid response");
+}
+async function handleStopPerformanceRecording(ctx, input) {
+  const session = ctx.performanceSessions.get(input.recordingId);
+  if (!session) {
+    return createToolError(`Performance recording not found: ${input.recordingId}`);
+  }
+  try {
+    if (session.source === "cdp") {
+      const client = activeCdpPerformanceClients.get(input.recordingId);
+      if (!client) {
+        return createToolError(
+          `CDP client not found for recording: ${input.recordingId}`
+        );
+      }
+      const report = await stopCdpPerformanceRecording({
+        client,
+        session
+      });
+      appendPerformanceReport(ctx, report);
+      return createToolResponse(toStructuredRecord(report));
+    }
+    const result = await requestRuntimeData(ctx, (event) => {
+      void ctx.rpcServer?.stopPerformanceRecording({
+        event,
+        recordingId: input.recordingId
+      });
+    });
+    if (isPerformanceReport(result)) {
+      appendPerformanceReport(ctx, result);
+    }
+    if (isPlainRecord(result)) {
+      return createToolResponse(toStructuredRecord(result));
+    }
+    return createToolError("runtime bridge returned an invalid response");
+  } finally {
+    ctx.performanceSessions.delete(input.recordingId);
+    const client = activeCdpPerformanceClients.get(input.recordingId);
+    if (client) {
+      activeCdpPerformanceClients.delete(input.recordingId);
+      await closeCdpClient(client);
+    }
+  }
+}
+function handleGetPerformanceReport(ctx, input) {
+  const reports = ctx.performanceReports.all().filter((report) => !input.pageId || report.pageId === input.pageId).filter(
+    (report) => !input.recordingId || report.recordingId === input.recordingId
+  );
+  const limit = input.limit ?? reports.length;
+  return createToolResponse(toStructuredRecord({
+    report: reports.at(-1) ?? null,
+    reports: reports.slice(-limit),
+    sessions: [...ctx.performanceSessions.values()].filter(
+      (session) => (!input.pageId || session.pageId === input.pageId) && (!input.recordingId || session.recordingId === input.recordingId)
+    )
+  }));
+}
+async function handleTakeHeapSnapshot(ctx, input) {
+  if (ctx.options.performance.mode === "off" || ctx.options.performance.mode === "hook") {
+    return createToolError(PERFORMANCE_NOT_AVAILABLE_ERROR);
+  }
+  const cdpResult = await connectPerformanceCdp(ctx, input.pageId);
+  const cdp = cdpResult.cdp;
+  if (!cdp) {
+    return createToolError(
+      formatCdpUnavailableError(
+        "CDP heap snapshot is unavailable",
+        cdpResult.error
+      )
+    );
+  }
+  try {
+    return createToolResponse(
+      toStructuredRecord(await takeHeapSnapshot({
+        client: cdp.client,
+        pageId: input.pageId ?? "cdp",
+        saveDir: ctx.options.performance.saveDir
+      }))
+    );
+  } finally {
+    await closeCdpClient(cdp.client);
+  }
+}
+async function connectPerformanceCdp(ctx, pageId) {
+  try {
+    return { cdp: await connectCdpForPage(ctx, pageId) };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatCdpUnavailableError(message, reason) {
+  if (!reason) {
+    return message;
+  }
+  return `${message}: ${reason}`;
+}
+function isPerformanceReport(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const report = value;
+  return typeof report.recordingId === "string" && typeof report.pageId === "string" && (report.source === "hook" || report.source === "cdp") && typeof report.startedAt === "number" && typeof report.endedAt === "number" && typeof report.durationMs === "number" && Boolean(report.summary) && Array.isArray(report.longTasks) && Array.isArray(report.limitations);
+}
+function isPerformanceStartResult(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const result = value;
+  return typeof result.recordingId === "string" && typeof result.startedAt === "number";
+}
+function isPlainRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toStructuredRecord(value) {
+  if (isPlainRecord(value)) {
+    return value;
+  }
+  return {};
+}
+
+// src/mcp/tools/pages.ts
+import { z as z6 } from "zod";
+
 // src/plugin/entryDiscovery.ts
 import fs from "fs";
 import path from "path";
@@ -691,10 +1316,10 @@ function walkHtmlEntries(root, dir, entries) {
     if (!item.isFile() || !item.name.endsWith(".html")) {
       continue;
     }
-    const relative = normalizePath(path.relative(root, fullPath));
+    const relative2 = normalizePath(path.relative(root, fullPath));
     entries.push({
-      file: relative,
-      pathname: relative === "index.html" ? "/" : `/${relative}`
+      file: relative2,
+      pathname: relative2 === "index.html" ? "/" : `/${relative2}`
     });
   }
 }
@@ -706,7 +1331,7 @@ function registerPageTools(server, ctx, vite) {
     {
       description: "List Vite page entries and connected runtime/CDP targets.",
       inputSchema: {
-        includeDisconnected: z5.boolean().optional()
+        includeDisconnected: z6.boolean().optional()
       }
     },
     async (input) => {
@@ -729,8 +1354,8 @@ function registerPageTools(server, ctx, vite) {
     {
       description: "Reload the selected page. CDP uses ignoreCache; Runtime Hook falls back to normal reload.",
       inputSchema: {
-        pageId: z5.string().optional(),
-        ignoreCache: z5.boolean().optional()
+        pageId: z6.string().optional(),
+        ignoreCache: z6.boolean().optional()
       }
     },
     async (input) => {
@@ -789,16 +1414,16 @@ function resolveRuntimeReloadTarget(ctx, pageId) {
 function waitForRuntimePageReconnect(ctx) {
   let timeout;
   let cleanup;
-  const promise = new Promise((resolve) => {
+  const promise = new Promise((resolve2) => {
     timeout = setTimeout(() => {
       cleanup?.();
-      resolve(null);
+      resolve2(null);
     }, 5e3);
     cleanup = ctx.hooks.hookOnce(RUNTIME_PAGE_RECONNECTED_EVENT, (payload) => {
       if (timeout) {
         clearTimeout(timeout);
       }
-      resolve(isPageTarget(payload) ? payload : null);
+      resolve2(isPageTarget(payload) ? payload : null);
     });
   });
   return {
@@ -882,7 +1507,7 @@ function getPathname(url) {
 }
 
 // src/mcp/tools/screenshot.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/cdp/cdpScreenshot.ts
 async function cdpCaptureScreenshot(options) {
@@ -988,16 +1613,16 @@ function isElementRect(value) {
 
 // src/mcp/tools/screenshotOutput.ts
 import { randomUUID } from "crypto";
-import { mkdir, writeFile } from "fs/promises";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
 import path2 from "path";
 async function createScreenshotOutput(ctx, payload) {
   if (ctx.options.screenshot.type === "base64") {
     return payload;
   }
   const saveDir = resolveScreenshotSaveDir(ctx);
-  await mkdir(saveDir, { recursive: true });
+  await mkdir2(saveDir, { recursive: true });
   const filePath = path2.join(saveDir, createScreenshotFileName(payload));
-  await writeFile(filePath, Buffer.from(payload.data, "base64"));
+  await writeFile2(filePath, Buffer.from(payload.data, "base64"));
   return {
     source: payload.source,
     target: payload.target,
@@ -1042,14 +1667,14 @@ function createProjectRelativePath(ctx, filePath) {
 var DEFAULT_SCREENSHOT_TARGET = "viewport";
 var DEFAULT_SCREENSHOT_FORMAT = "png";
 var screenshotInputSchema = {
-  pageId: z6.string().optional(),
-  target: z6.enum(["viewport", "fullPage", "element"]).optional(),
-  selector: z6.string().optional(),
-  format: z6.enum(["png", "jpeg", "webp"]).optional(),
-  prefer: z6.enum(["auto", "cdp", "runtime"]).optional(),
-  quality: z6.number().optional(),
-  scale: z6.number().optional(),
-  snapdom: z6.record(z6.string(), z6.unknown()).optional()
+  pageId: z7.string().optional(),
+  target: z7.enum(["viewport", "fullPage", "element"]).optional(),
+  selector: z7.string().optional(),
+  format: z7.enum(["png", "jpeg", "webp"]).optional(),
+  prefer: z7.enum(["auto", "cdp", "runtime"]).optional(),
+  quality: z7.number().optional(),
+  scale: z7.number().optional(),
+  snapdom: z7.record(z7.string(), z7.unknown()).optional()
 };
 function registerScreenshotTools(server, ctx) {
   server.registerTool(
@@ -1122,7 +1747,7 @@ async function createRuntimeScreenshot(ctx, input, normalized) {
       `screenshot is too large: ${String(result.byteLength)} bytes`
     );
   }
-  if (!isPlainRecord(result)) {
+  if (!isPlainRecord2(result)) {
     return createToolError("runtime screenshot returned an invalid response");
   }
   if (result.ok === false) {
@@ -1151,9 +1776,9 @@ async function createScreenshotResponse(ctx, result) {
   }
 }
 function isScreenshotTooLarge(ctx, result) {
-  return isPlainRecord(result) && "byteLength" in result && typeof result.byteLength === "number" && result.byteLength > ctx.options.screenshot.maxBytes;
+  return isPlainRecord2(result) && "byteLength" in result && typeof result.byteLength === "number" && result.byteLength > ctx.options.screenshot.maxBytes;
 }
-function isPlainRecord(value) {
+function isPlainRecord2(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function createMimeType(format) {
@@ -1168,8 +1793,8 @@ function isScreenshotImagePayload(result) {
 }
 
 // src/mcp/tools/vue.ts
-import { nanoid as nanoid2 } from "nanoid";
-import { z as z7 } from "zod";
+import { nanoid as nanoid3 } from "nanoid";
+import { z as z8 } from "zod";
 function registerVueTools(server, ctx) {
   server.registerTool(
     MCP_TOOL_NAMES.getComponentTree,
@@ -1182,7 +1807,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getComponentState,
     {
       description: "Get Vue component state.",
-      inputSchema: { componentName: z7.string() }
+      inputSchema: { componentName: z8.string() }
     },
     async ({ componentName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getInspectorState({ event, componentName });
@@ -1193,10 +1818,10 @@ function registerVueTools(server, ctx) {
     {
       description: "Edit Vue component state.",
       inputSchema: {
-        componentName: z7.string(),
-        path: z7.array(z7.string()),
-        value: z7.string(),
-        valueType: z7.enum(["string", "number", "boolean", "object", "array"])
+        componentName: z8.string(),
+        path: z8.array(z8.string()),
+        value: z8.string(),
+        valueType: z8.enum(["string", "number", "boolean", "object", "array"])
       }
     },
     ({ componentName, path: path8, value, valueType }) => {
@@ -1216,7 +1841,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.highlightComponent,
     {
       description: "Highlight a Vue component.",
-      inputSchema: { componentName: z7.string() }
+      inputSchema: { componentName: z8.string() }
     },
     ({ componentName }) => {
       if (!ctx.rpcServer) {
@@ -1244,7 +1869,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getPiniaState,
     {
       description: "Get Pinia store state.",
-      inputSchema: { storeName: z7.string() }
+      inputSchema: { storeName: z8.string() }
     },
     async ({ storeName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getPiniaState({ event, storeName });
@@ -1255,7 +1880,7 @@ async function requestVueData(ctx, trigger) {
   if (!ctx.rpcServer) {
     return vueBridgeUnavailable();
   }
-  const event = nanoid2();
+  const event = nanoid3();
   const data = await waitForVueHook(ctx, event, () => {
     trigger(event);
   });
@@ -1264,13 +1889,13 @@ async function requestVueData(ctx, trigger) {
   };
 }
 function waitForVueHook(ctx, event, trigger) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const timeout = setTimeout(() => {
-      resolve({ ok: false, error: "Vue runtime bridge response timed out" });
+      resolve2({ ok: false, error: "Vue runtime bridge response timed out" });
     }, 5e3);
     ctx.hooks.hookOnce(event, (data) => {
       clearTimeout(timeout);
-      resolve(data);
+      resolve2(data);
     });
     trigger();
   });
@@ -1291,6 +1916,7 @@ function createMcpServer(ctx, vite) {
   registerConsoleTools(server, ctx);
   registerEvaluateTools(server, ctx);
   registerNetworkTools(server, ctx);
+  registerPerformanceTools(server, ctx);
   registerVueTools(server, ctx);
   return server;
 }
@@ -1378,6 +2004,18 @@ function createServerVueRuntimeRpc(ctx) {
     onScreenshotTaken: (event, data) => {
       void ctx.hooks.callHook(event, data);
     },
+    recordPerformance: () => void 0,
+    onPerformanceRecorded: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    startPerformanceRecording: () => void 0,
+    onPerformanceRecordingStarted: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
+    stopPerformanceRecording: () => void 0,
+    onPerformanceRecordingStopped: (event, data) => {
+      void ctx.hooks.callHook(event, data);
+    },
     getInspectorTree: () => void 0,
     onInspectorTreeUpdated: (event, data) => {
       void ctx.hooks.callHook(event, data);
@@ -1404,7 +2042,7 @@ function createServerVueRuntimeRpc(ctx) {
 }
 
 // src/cdp/cdpConsole.ts
-import { nanoid as nanoid3 } from "nanoid";
+import { nanoid as nanoid4 } from "nanoid";
 
 // src/shared/serialization.ts
 function safeStringify(value) {
@@ -1433,7 +2071,7 @@ async function startCdpConsole(options) {
   await options.client.Runtime.enable();
   options.client.Runtime.consoleAPICalled((event) => {
     options.push({
-      id: nanoid3(),
+      id: nanoid4(),
       pageId: options.pageId,
       source: "cdp",
       level: normalizeConsoleLevel(event.type),
@@ -1453,7 +2091,7 @@ function normalizeConsoleLevel(level) {
 }
 
 // src/cdp/cdpNetwork.ts
-import { nanoid as nanoid4 } from "nanoid";
+import { nanoid as nanoid5 } from "nanoid";
 
 // src/shared/sanitize.ts
 function maskHeaders(headers = {}, maskNames = []) {
@@ -1493,7 +2131,7 @@ async function startCdpNetwork(options) {
   await options.client.Network.enable();
   options.client.Network.requestWillBeSent((event) => {
     records.set(event.requestId, {
-      id: nanoid4(),
+      id: nanoid5(),
       pageId: options.pageId,
       source: "cdp",
       url: event.request.url,
@@ -1901,11 +2539,11 @@ import path4 from "path";
 async function updateJsonMcpClientConfig(options) {
   try {
     const config = await readJsonConfig(options.configPath);
-    if (!isPlainRecord2(config)) {
+    if (!isPlainRecord3(config)) {
       warnConfigFailure(options, "config root must be a JSON object");
       return;
     }
-    const mcpServers = isPlainRecord2(config.mcpServers) ? config.mcpServers : {};
+    const mcpServers = isPlainRecord3(config.mcpServers) ? config.mcpServers : {};
     if (Object.hasOwn(mcpServers, options.serverName)) {
       return;
     }
@@ -1958,7 +2596,7 @@ async function readOptionalTextFile2(filePath) {
     throw error;
   }
 }
-function isPlainRecord2(value) {
+function isPlainRecord3(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function warnConfigFailure(options, reason) {
@@ -2300,6 +2938,14 @@ function vueMcpNext(userOptions = {}) {
           }
         }
       );
+      server.ws.on(
+        "vite-plugin-vue-mcp-next:performance-record",
+        (payload) => {
+          if (isPerformanceReport2(payload)) {
+            appendPerformanceReport(ctx, payload);
+          }
+        }
+      );
       const port = String(server.config.server.port || 5173);
       const mcpSseUrl = `http://${options.host}:${port}${options.mcpPath}/sse`;
       const mcpStreamableHttpUrl = `http://${options.host}:${port}${options.mcpPath}/mcp`;
@@ -2362,6 +3008,13 @@ function isNetworkRecord(payload) {
   const record = payload;
   return typeof record.id === "string" && typeof record.pageId === "string" && record.source === "hook" && typeof record.url === "string" && typeof record.method === "string" && typeof record.startedAt === "number";
 }
+function isPerformanceReport2(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const report = payload;
+  return typeof report.recordingId === "string" && typeof report.pageId === "string" && (report.source === "hook" || report.source === "cdp") && Boolean(report.summary) && Array.isArray(report.longTasks) && Array.isArray(report.limitations);
+}
 export {
   vueMcpNext as default,
   vueMcpNext