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

package/dist/index.cjs

@@ -55,6 +55,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",
@@ -67,6 +72,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",
@@ -135,6 +145,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) {
@@ -204,6 +227,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
+      }
     }
   };
 }
@@ -231,24 +266,64 @@ function createRingBuffer(capacity) {
 }
 
 // src/context.ts
+var MINUTE_MS = 60 * 1e3;
+var DISCONNECTED_RUNTIME_TARGET_RETENTION_MS = 5 * MINUTE_MS;
+function shouldPruneDisconnectedRuntimeTarget(target, now) {
+  return target.source === "runtime" && !target.connected && typeof target.disconnectedAt === "number" && now - target.disconnectedAt > DISCONNECTED_RUNTIME_TARGET_RETENTION_MS;
+}
+function pruneDisconnectedRuntimeTargets(targets, now) {
+  for (const [pageId, target] of targets) {
+    if (shouldPruneDisconnectedRuntimeTarget(target, now)) {
+      targets.delete(pageId);
+    }
+  }
+}
+function markTargetDisconnected(target, now) {
+  return {
+    ...target,
+    connected: false,
+    disconnectedAt: target.disconnectedAt ?? now
+  };
+}
+function shouldListPageTarget(target, options) {
+  return options.includeDisconnected === true || target.source !== "runtime" || target.connected;
+}
+function disconnectPreviousRuntimeClientTarget(targets, target, now) {
+  if (target.source !== "runtime" || !target.runtimeClientId) {
+    return;
+  }
+  for (const [pageId, currentTarget] of targets) {
+    if (pageId === target.pageId || currentTarget.source !== "runtime" || currentTarget.runtimeClientId !== target.runtimeClientId || !currentTarget.connected) {
+      continue;
+    }
+    targets.set(pageId, markTargetDisconnected(currentTarget, now));
+  }
+}
 function createPageTargetRegistry() {
   const targets = /* @__PURE__ */ new Map();
   return {
-    upsert(target) {
+    upsert(target, now = Date.now()) {
+      pruneDisconnectedRuntimeTargets(targets, now);
+      disconnectPreviousRuntimeClientTarget(targets, target, now);
       targets.set(target.pageId, target);
     },
     get(pageId) {
       return targets.get(pageId);
     },
-    list() {
-      return [...targets.values()];
+    list(options = {}) {
+      const now = options.now ?? Date.now();
+      pruneDisconnectedRuntimeTargets(targets, now);
+      return [...targets.values()].filter(
+        (target) => shouldListPageTarget(target, options)
+      );
     },
-    disconnect(pageId) {
+    disconnect(pageId, now = Date.now()) {
+      pruneDisconnectedRuntimeTargets(targets, now);
       const target = targets.get(pageId);
       if (!target) {
         return;
       }
-      targets.set(pageId, { ...target, connected: false });
+      targets.set(pageId, markTargetDisconnected(target, now));
     }
   };
 }
@@ -259,7 +334,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()
   };
 }
 
@@ -377,13 +456,13 @@ async function requestRuntimeData(ctx, trigger) {
     return { ok: false, error: "runtime bridge is not connected" };
   }
   const event = (0, import_nanoid.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);
   });
@@ -662,12 +741,598 @@ function registerNetworkTools(server, ctx) {
   );
 }
 
-// src/mcp/tools/pages.ts
+// src/mcp/tools/performance.ts
 var import_zod5 = require("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
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_nanoid2 = require("nanoid");
+async function writePerformanceArtifact(options) {
+  const root = (0, import_node_path.resolve)(options.root ?? process.cwd());
+  const dir = resolveOutputDirectory(root, options.saveDir);
+  const path8 = (0, import_node_path.resolve)(dir, createSafeFileName(options.fileName));
+  const data = typeof options.data === "string" ? Buffer.from(options.data) : options.data;
+  await (0, import_promises.mkdir)(dir, { recursive: true });
+  await (0, import_promises.writeFile)(path8, data);
+  return {
+    kind: options.kind,
+    path: path8,
+    relativePath: (0, import_node_path.relative)(root, path8),
+    byteLength: data.byteLength,
+    source: "cdp"
+  };
+}
+function resolveOutputDirectory(root, saveDir) {
+  return (0, import_node_path.resolve)(root, saveDir);
+}
+function createSafeFileName(fileName) {
+  const trimmed = fileName.trim();
+  if (!trimmed) {
+    return `${String(Date.now())}-${(0, import_nanoid2.nanoid)()}`;
+  }
+  const suffix = (0, import_nanoid2.nanoid)(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: import_zod5.z.string().optional(),
+        durationMs: import_zod5.z.number().optional(),
+        includeMemory: import_zod5.z.boolean().optional(),
+        includeStacks: import_zod5.z.boolean().optional()
+      }
+    },
+    async (input) => handleRecordPerformance(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.startPerformanceRecording,
+    {
+      description: "Start a performance recording session.",
+      inputSchema: {
+        pageId: import_zod5.z.string().optional(),
+        includeMemory: import_zod5.z.boolean().optional(),
+        includeStacks: import_zod5.z.boolean().optional()
+      }
+    },
+    async (input) => handleStartPerformanceRecording(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.stopPerformanceRecording,
+    {
+      description: "Stop a performance recording session.",
+      inputSchema: {
+        recordingId: import_zod5.z.string()
+      }
+    },
+    async (input) => handleStopPerformanceRecording(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.getPerformanceReport,
+    {
+      description: "Get cached performance reports and active sessions.",
+      inputSchema: {
+        pageId: import_zod5.z.string().optional(),
+        recordingId: import_zod5.z.string().optional(),
+        limit: import_zod5.z.number().optional()
+      }
+    },
+    (input) => handleGetPerformanceReport(ctx, input)
+  );
+  server.registerTool(
+    MCP_TOOL_NAMES.takeHeapSnapshot,
+    {
+      description: "Take a heap snapshot with CDP.",
+      inputSchema: {
+        pageId: import_zod5.z.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
+var import_zod6 = require("zod");
+
 // src/plugin/entryDiscovery.ts
 var import_node_fs = __toESM(require("fs"), 1);
-var import_node_path = __toESM(require("path"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
 var import_vite = require("vite");
 function discoverHtmlEntries(server) {
   const root = server.config.root;
@@ -680,7 +1345,7 @@ function walkHtmlEntries(root, dir, entries) {
     if (item.name === "node_modules" || item.name.startsWith(".")) {
       continue;
     }
-    const fullPath = import_node_path.default.join(dir, item.name);
+    const fullPath = import_node_path2.default.join(dir, item.name);
     if (item.isDirectory()) {
       walkHtmlEntries(root, fullPath, entries);
       continue;
@@ -688,10 +1353,10 @@ function walkHtmlEntries(root, dir, entries) {
     if (!item.isFile() || !item.name.endsWith(".html")) {
       continue;
     }
-    const relative = (0, import_vite.normalizePath)(import_node_path.default.relative(root, fullPath));
+    const relative2 = (0, import_vite.normalizePath)(import_node_path2.default.relative(root, fullPath));
     entries.push({
-      file: relative,
-      pathname: relative === "index.html" ? "/" : `/${relative}`
+      file: relative2,
+      pathname: relative2 === "index.html" ? "/" : `/${relative2}`
     });
   }
 }
@@ -701,9 +1366,12 @@ function registerPageTools(server, ctx, vite) {
   server.registerTool(
     MCP_TOOL_NAMES.listPages,
     {
-      description: "List Vite page entries and connected runtime/CDP targets."
+      description: "List Vite page entries and connected runtime/CDP targets.",
+      inputSchema: {
+        includeDisconnected: import_zod6.z.boolean().optional()
+      }
     },
-    async () => {
+    async (input) => {
       const cdpResult = await listCdpPageTargets(ctx);
       for (const target of cdpResult.pages) {
         ctx.pages.upsert(target);
@@ -711,7 +1379,9 @@ function registerPageTools(server, ctx, vite) {
       }
       return createToolResponse({
         entries: discoverHtmlEntries(vite),
-        pages: ctx.pages.list(),
+        pages: ctx.pages.list({
+          includeDisconnected: input.includeDisconnected
+        }),
         cdpError: cdpResult.error
       });
     }
@@ -721,8 +1391,8 @@ function registerPageTools(server, ctx, vite) {
     {
       description: "Reload the selected page. CDP uses ignoreCache; Runtime Hook falls back to normal reload.",
       inputSchema: {
-        pageId: import_zod5.z.string().optional(),
-        ignoreCache: import_zod5.z.boolean().optional()
+        pageId: import_zod6.z.string().optional(),
+        ignoreCache: import_zod6.z.boolean().optional()
       }
     },
     async (input) => {
@@ -781,16 +1451,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 {
@@ -874,7 +1544,7 @@ function getPathname(url) {
 }
 
 // src/mcp/tools/screenshot.ts
-var import_zod6 = require("zod");
+var import_zod7 = require("zod");
 
 // src/cdp/cdpScreenshot.ts
 async function cdpCaptureScreenshot(options) {
@@ -980,16 +1650,16 @@ function isElementRect(value) {
 
 // src/mcp/tools/screenshotOutput.ts
 var import_node_crypto = require("crypto");
-var import_promises = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises2 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 async function createScreenshotOutput(ctx, payload) {
   if (ctx.options.screenshot.type === "base64") {
     return payload;
   }
   const saveDir = resolveScreenshotSaveDir(ctx);
-  await (0, import_promises.mkdir)(saveDir, { recursive: true });
-  const filePath = import_node_path2.default.join(saveDir, createScreenshotFileName(payload));
-  await (0, import_promises.writeFile)(filePath, Buffer.from(payload.data, "base64"));
+  await (0, import_promises2.mkdir)(saveDir, { recursive: true });
+  const filePath = import_node_path3.default.join(saveDir, createScreenshotFileName(payload));
+  await (0, import_promises2.writeFile)(filePath, Buffer.from(payload.data, "base64"));
   return {
     source: payload.source,
     target: payload.target,
@@ -1012,10 +1682,10 @@ function resolveScreenshotSaveDir(ctx) {
   if (!root) {
     throw new Error("Vite server root is required for screenshot path output");
   }
-  if (import_node_path2.default.isAbsolute(saveDir)) {
+  if (import_node_path3.default.isAbsolute(saveDir)) {
     return saveDir;
   }
-  return import_node_path2.default.resolve(root, saveDir);
+  return import_node_path3.default.resolve(root, saveDir);
 }
 function createScreenshotFileName(payload) {
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
@@ -1027,21 +1697,21 @@ function createProjectRelativePath(ctx, filePath) {
   if (!root) {
     throw new Error("Vite server root is required for screenshot path output");
   }
-  return import_node_path2.default.relative(root, filePath).split(import_node_path2.default.sep).join("/");
+  return import_node_path3.default.relative(root, filePath).split(import_node_path3.default.sep).join("/");
 }
 
 // src/mcp/tools/screenshot.ts
 var DEFAULT_SCREENSHOT_TARGET = "viewport";
 var DEFAULT_SCREENSHOT_FORMAT = "png";
 var screenshotInputSchema = {
-  pageId: import_zod6.z.string().optional(),
-  target: import_zod6.z.enum(["viewport", "fullPage", "element"]).optional(),
-  selector: import_zod6.z.string().optional(),
-  format: import_zod6.z.enum(["png", "jpeg", "webp"]).optional(),
-  prefer: import_zod6.z.enum(["auto", "cdp", "runtime"]).optional(),
-  quality: import_zod6.z.number().optional(),
-  scale: import_zod6.z.number().optional(),
-  snapdom: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.unknown()).optional()
+  pageId: import_zod7.z.string().optional(),
+  target: import_zod7.z.enum(["viewport", "fullPage", "element"]).optional(),
+  selector: import_zod7.z.string().optional(),
+  format: import_zod7.z.enum(["png", "jpeg", "webp"]).optional(),
+  prefer: import_zod7.z.enum(["auto", "cdp", "runtime"]).optional(),
+  quality: import_zod7.z.number().optional(),
+  scale: import_zod7.z.number().optional(),
+  snapdom: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.unknown()).optional()
 };
 function registerScreenshotTools(server, ctx) {
   server.registerTool(
@@ -1114,7 +1784,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) {
@@ -1143,9 +1813,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) {
@@ -1160,8 +1830,8 @@ function isScreenshotImagePayload(result) {
 }
 
 // src/mcp/tools/vue.ts
-var import_nanoid2 = require("nanoid");
-var import_zod7 = require("zod");
+var import_nanoid3 = require("nanoid");
+var import_zod8 = require("zod");
 function registerVueTools(server, ctx) {
   server.registerTool(
     MCP_TOOL_NAMES.getComponentTree,
@@ -1174,7 +1844,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getComponentState,
     {
       description: "Get Vue component state.",
-      inputSchema: { componentName: import_zod7.z.string() }
+      inputSchema: { componentName: import_zod8.z.string() }
     },
     async ({ componentName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getInspectorState({ event, componentName });
@@ -1185,10 +1855,10 @@ function registerVueTools(server, ctx) {
     {
       description: "Edit Vue component state.",
       inputSchema: {
-        componentName: import_zod7.z.string(),
-        path: import_zod7.z.array(import_zod7.z.string()),
-        value: import_zod7.z.string(),
-        valueType: import_zod7.z.enum(["string", "number", "boolean", "object", "array"])
+        componentName: import_zod8.z.string(),
+        path: import_zod8.z.array(import_zod8.z.string()),
+        value: import_zod8.z.string(),
+        valueType: import_zod8.z.enum(["string", "number", "boolean", "object", "array"])
       }
     },
     ({ componentName, path: path8, value, valueType }) => {
@@ -1208,7 +1878,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.highlightComponent,
     {
       description: "Highlight a Vue component.",
-      inputSchema: { componentName: import_zod7.z.string() }
+      inputSchema: { componentName: import_zod8.z.string() }
     },
     ({ componentName }) => {
       if (!ctx.rpcServer) {
@@ -1236,7 +1906,7 @@ function registerVueTools(server, ctx) {
     MCP_TOOL_NAMES.getPiniaState,
     {
       description: "Get Pinia store state.",
-      inputSchema: { storeName: import_zod7.z.string() }
+      inputSchema: { storeName: import_zod8.z.string() }
     },
     async ({ storeName }) => requestVueData(ctx, (event) => {
       void ctx.rpcServer?.getPiniaState({ event, storeName });
@@ -1247,7 +1917,7 @@ async function requestVueData(ctx, trigger) {
   if (!ctx.rpcServer) {
     return vueBridgeUnavailable();
   }
-  const event = (0, import_nanoid2.nanoid)();
+  const event = (0, import_nanoid3.nanoid)();
   const data = await waitForVueHook(ctx, event, () => {
     trigger(event);
   });
@@ -1256,13 +1926,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();
   });
@@ -1283,6 +1953,7 @@ function createMcpServer(ctx, vite) {
   registerConsoleTools(server, ctx);
   registerEvaluateTools(server, ctx);
   registerNetworkTools(server, ctx);
+  registerPerformanceTools(server, ctx);
   registerVueTools(server, ctx);
   return server;
 }
@@ -1370,6 +2041,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);
@@ -1396,7 +2079,7 @@ function createServerVueRuntimeRpc(ctx) {
 }
 
 // src/cdp/cdpConsole.ts
-var import_nanoid3 = require("nanoid");
+var import_nanoid4 = require("nanoid");
 
 // src/shared/serialization.ts
 function safeStringify(value) {
@@ -1425,7 +2108,7 @@ async function startCdpConsole(options) {
   await options.client.Runtime.enable();
   options.client.Runtime.consoleAPICalled((event) => {
     options.push({
-      id: (0, import_nanoid3.nanoid)(),
+      id: (0, import_nanoid4.nanoid)(),
       pageId: options.pageId,
       source: "cdp",
       level: normalizeConsoleLevel(event.type),
@@ -1445,7 +2128,7 @@ function normalizeConsoleLevel(level) {
 }
 
 // src/cdp/cdpNetwork.ts
-var import_nanoid4 = require("nanoid");
+var import_nanoid5 = require("nanoid");
 
 // src/shared/sanitize.ts
 function maskHeaders(headers = {}, maskNames = []) {
@@ -1485,7 +2168,7 @@ async function startCdpNetwork(options) {
   await options.client.Network.enable();
   options.client.Network.requestWillBeSent((event) => {
     records.set(event.requestId, {
-      id: (0, import_nanoid4.nanoid)(),
+      id: (0, import_nanoid5.nanoid)(),
       pageId: options.pageId,
       source: "cdp",
       url: event.request.url,
@@ -1656,7 +2339,7 @@ async function startCdpObservers(ctx, target, client) {
 
 // src/plugin/injectRuntime.ts
 var import_node_module = require("module");
-var import_node_path3 = require("path");
+var import_node_path4 = require("path");
 function createRuntimeInjectionController(options, getConfig) {
   return {
     resolveId(importee) {
@@ -1740,7 +2423,7 @@ function createSnapdomLoaderModule(root) {
 }
 function canResolveSnapdomFromProject(root) {
   try {
-    (0, import_node_module.createRequire)((0, import_node_path3.join)(root ?? process.cwd(), "package.json")).resolve(
+    (0, import_node_module.createRequire)((0, import_node_path4.join)(root ?? process.cwd(), "package.json")).resolve(
       "@zumer/snapdom"
     );
     return true;
@@ -1779,18 +2462,18 @@ function getPluginPath(plugin) {
 }
 
 // src/plugin/mcpClientConfig/index.ts
-var import_promises4 = __toESM(require("fs/promises"), 1);
-var import_node_path6 = __toESM(require("path"), 1);
+var import_promises5 = __toESM(require("fs/promises"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 
 // src/plugin/mcpClientConfig/codexConfig.ts
-var import_promises2 = __toESM(require("fs/promises"), 1);
-var import_node_path4 = __toESM(require("path"), 1);
+var import_promises3 = __toESM(require("fs/promises"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 async function updateCodexMcpClientConfig(options) {
   try {
     const current = await readOptionalTextFile(options.configPath);
     const next = replaceOrAppendOwnedBlock(current, options);
-    await import_promises2.default.mkdir(import_node_path4.default.dirname(options.configPath), { recursive: true });
-    await import_promises2.default.writeFile(options.configPath, next);
+    await import_promises3.default.mkdir(import_node_path5.default.dirname(options.configPath), { recursive: true });
+    await import_promises3.default.writeFile(options.configPath, next);
   } catch (error) {
     console.warn(
       `[vite-plugin-vue-mcp-next] Failed to update Codex MCP config at ${options.configPath}: ${formatError(error)}`
@@ -1862,7 +2545,7 @@ function renameServerTableHeader(line, fromServerName, toServerName) {
 }
 async function readOptionalTextFile(filePath) {
   try {
-    return await import_promises2.default.readFile(filePath, "utf-8");
+    return await import_promises3.default.readFile(filePath, "utf-8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return "";
@@ -1888,16 +2571,16 @@ function isNodeError(error) {
 }
 
 // src/plugin/mcpClientConfig/jsonConfig.ts
-var import_promises3 = __toESM(require("fs/promises"), 1);
-var import_node_path5 = __toESM(require("path"), 1);
+var import_promises4 = __toESM(require("fs/promises"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 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;
     }
@@ -1929,8 +2612,8 @@ function renameLegacyServer(mcpServers, options) {
   );
 }
 async function writeJsonConfig(configPath, config) {
-  await import_promises3.default.mkdir(import_node_path5.default.dirname(configPath), { recursive: true });
-  await import_promises3.default.writeFile(configPath, `${JSON.stringify(config, null, 2)}
+  await import_promises4.default.mkdir(import_node_path6.default.dirname(configPath), { recursive: true });
+  await import_promises4.default.writeFile(configPath, `${JSON.stringify(config, null, 2)}
 `);
 }
 async function readJsonConfig(configPath) {
@@ -1942,7 +2625,7 @@ async function readJsonConfig(configPath) {
 }
 async function readOptionalTextFile2(filePath) {
   try {
-    return await import_promises3.default.readFile(filePath, "utf-8");
+    return await import_promises4.default.readFile(filePath, "utf-8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
       return "{}";
@@ -1950,7 +2633,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) {
@@ -1974,12 +2657,12 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options,
       root,
       clientName: "cursor",
       enabled: options.cursor,
-      entryPath: import_node_path6.default.join(root, ".cursor"),
+      entryPath: import_node_path7.default.join(root, ".cursor"),
       entryKind: "directory",
       userOptions,
       createJob: () => updateJsonMcpClientConfig({
         clientName: "Cursor",
-        configPath: import_node_path6.default.join(root, ".cursor", "mcp.json"),
+        configPath: import_node_path7.default.join(root, ".cursor", "mcp.json"),
         mcpUrl: sseUrl,
         serverName,
         legacyServerNames
@@ -1989,11 +2672,11 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options,
       root,
       clientName: "codex",
       enabled: options.codex,
-      entryPath: import_node_path6.default.join(root, ".codex"),
+      entryPath: import_node_path7.default.join(root, ".codex"),
       entryKind: "directory",
       userOptions,
       createJob: () => updateCodexMcpClientConfig({
-        configPath: import_node_path6.default.join(root, ".codex", "config.toml"),
+        configPath: import_node_path7.default.join(root, ".codex", "config.toml"),
         mcpUrl: streamableHttpUrl,
         serverName,
         legacyServerNames
@@ -2003,12 +2686,12 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options,
       root,
       clientName: "claudeCode",
       enabled: options.claudeCode,
-      entryPath: import_node_path6.default.join(root, ".mcp.json"),
+      entryPath: import_node_path7.default.join(root, ".mcp.json"),
       entryKind: "file",
       userOptions,
       createJob: () => updateJsonMcpClientConfig({
         clientName: "Claude Code",
-        configPath: import_node_path6.default.join(root, ".mcp.json"),
+        configPath: import_node_path7.default.join(root, ".mcp.json"),
         mcpUrl: sseUrl,
         serverName,
         legacyServerNames
@@ -2018,12 +2701,12 @@ async function updateMcpClientConfigs(root, sseUrl, streamableHttpUrl, options,
       root,
       clientName: "trae",
       enabled: options.trae,
-      entryPath: import_node_path6.default.join(root, ".trae"),
+      entryPath: import_node_path7.default.join(root, ".trae"),
       entryKind: "directory",
       userOptions,
       createJob: () => updateJsonMcpClientConfig({
         clientName: "Trae",
-        configPath: import_node_path6.default.join(root, ".trae", "mcp.json"),
+        configPath: import_node_path7.default.join(root, ".trae", "mcp.json"),
         mcpUrl: sseUrl,
         serverName,
         legacyServerNames
@@ -2062,7 +2745,7 @@ function isClientExplicitlyConfigured(clientName, userOptions) {
 }
 async function hasExpectedEntry(entryPath, entryKind) {
   try {
-    const stat = await import_promises4.default.stat(entryPath);
+    const stat = await import_promises5.default.stat(entryPath);
     return entryKind === "directory" ? stat.isDirectory() : stat.isFile();
   } catch (error) {
     if (isNodeError3(error) && error.code === "ENOENT") {
@@ -2082,12 +2765,12 @@ function isNodeError3(error) {
 }
 
 // src/plugin/skillConfig/index.ts
-var import_promises6 = __toESM(require("fs/promises"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
+var import_promises7 = __toESM(require("fs/promises"), 1);
+var import_node_path9 = __toESM(require("path"), 1);
 
 // src/plugin/skillConfig/writers.ts
-var import_promises5 = __toESM(require("fs/promises"), 1);
-var import_node_path7 = __toESM(require("path"), 1);
+var import_promises6 = __toESM(require("fs/promises"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var GENERATED_SKILL_CONFIG_MARKER = "<!-- Generated by vite-plugin-vue-mcp-next. Safe to edit, but automatic updates only apply while this marker remains. -->";
 async function writeGeneratedTextFile(options) {
   try {
@@ -2098,8 +2781,8 @@ async function writeGeneratedTextFile(options) {
       );
       return;
     }
-    await import_promises5.default.mkdir(import_node_path7.default.dirname(options.filePath), { recursive: true });
-    await import_promises5.default.writeFile(options.filePath, options.content);
+    await import_promises6.default.mkdir(import_node_path8.default.dirname(options.filePath), { recursive: true });
+    await import_promises6.default.writeFile(options.filePath, options.content);
   } catch (error) {
     console.warn(
       `[vite-plugin-vue-mcp-next] Failed to update ${options.targetName} at ${options.filePath}: ${formatError4(error)}`
@@ -2108,7 +2791,7 @@ async function writeGeneratedTextFile(options) {
 }
 async function readOptionalTextFile3(filePath) {
   try {
-    return await import_promises5.default.readFile(filePath, "utf-8");
+    return await import_promises6.default.readFile(filePath, "utf-8");
   } catch (error) {
     if (isNodeError4(error) && error.code === "ENOENT") {
       return "";
@@ -2125,7 +2808,7 @@ function isNodeError4(error) {
 
 // src/plugin/skillConfig/index.ts
 var PACKAGE_NAME = "@xiaou66/vite-plugin-vue-mcp-next";
-var PACKAGED_SKILL_PATH = import_node_path8.default.join("skills", "vite-mcp-next", "SKILL.md");
+var PACKAGED_SKILL_PATH = import_node_path9.default.join("skills", "vite-mcp-next", "SKILL.md");
 async function updateSkillConfigs(root, options) {
   if (!options.autoConfig) {
     return;
@@ -2141,13 +2824,13 @@ async function updateSkillConfigs(root, options) {
 function createSkillConfigDescriptors(root) {
   return [
     {
-      entryPath: import_node_path8.default.join(root, ".codex"),
-      filePath: import_node_path8.default.join(root, ".codex", "skills", "vite-mcp-next", "SKILL.md"),
+      entryPath: import_node_path9.default.join(root, ".codex"),
+      filePath: import_node_path9.default.join(root, ".codex", "skills", "vite-mcp-next", "SKILL.md"),
       targetName: "Codex skill"
     },
     {
-      entryPath: import_node_path8.default.join(root, ".claude"),
-      filePath: import_node_path8.default.join(
+      entryPath: import_node_path9.default.join(root, ".claude"),
+      filePath: import_node_path9.default.join(
         root,
         ".claude",
         "skills",
@@ -2157,8 +2840,8 @@ function createSkillConfigDescriptors(root) {
       targetName: "Claude Code skill"
     },
     {
-      entryPath: import_node_path8.default.join(root, ".cursor"),
-      filePath: import_node_path8.default.join(root, ".cursor", "rules", "vite-mcp-next.mdc"),
+      entryPath: import_node_path9.default.join(root, ".cursor"),
+      filePath: import_node_path9.default.join(root, ".cursor", "rules", "vite-mcp-next.mdc"),
       targetName: "Cursor rule"
     }
   ];
@@ -2182,7 +2865,7 @@ async function readPackagedSkillContent(root) {
   const candidates = getPackagedSkillCandidates(root);
   for (const candidate of candidates) {
     try {
-      return await import_promises6.default.readFile(candidate, "utf-8");
+      return await import_promises7.default.readFile(candidate, "utf-8");
     } catch (error) {
       if (isNodeError5(error) && error.code === "ENOENT") {
         continue;
@@ -2206,14 +2889,14 @@ async function safelyReadPackagedSkillContent(root) {
 }
 function getPackagedSkillCandidates(root) {
   return [
-    import_node_path8.default.resolve(root, "node_modules", PACKAGE_NAME, PACKAGED_SKILL_PATH),
-    import_node_path8.default.resolve(process.cwd(), "node_modules", PACKAGE_NAME, PACKAGED_SKILL_PATH),
-    import_node_path8.default.resolve(process.cwd(), PACKAGED_SKILL_PATH)
+    import_node_path9.default.resolve(root, "node_modules", PACKAGE_NAME, PACKAGED_SKILL_PATH),
+    import_node_path9.default.resolve(process.cwd(), "node_modules", PACKAGE_NAME, PACKAGED_SKILL_PATH),
+    import_node_path9.default.resolve(process.cwd(), PACKAGED_SKILL_PATH)
   ];
 }
 async function hasDirectoryEntry(entryPath) {
   try {
-    const stat = await import_promises6.default.stat(entryPath);
+    const stat = await import_promises7.default.stat(entryPath);
     return stat.isDirectory();
   } catch (error) {
     if (isNodeError5(error) && error.code === "ENOENT") {
@@ -2292,6 +2975,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`;
@@ -2335,7 +3026,7 @@ function isRuntimePageTarget(payload) {
     return false;
   }
   const target = payload;
-  return target.source === "runtime" && typeof target.pageId === "string" && typeof target.url === "string" && typeof target.pathname === "string" && typeof target.connected === "boolean";
+  return target.source === "runtime" && typeof target.pageId === "string" && typeof target.url === "string" && typeof target.pathname === "string" && typeof target.connected === "boolean" && (target.runtimeClientId === void 0 || typeof target.runtimeClientId === "string");
 }
 function isConsoleRecord(payload) {
   if (!payload || typeof payload !== "object") {
@@ -2354,6 +3045,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);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   vueMcpNext