webperf-core-web-vitals（webperf 核心 Web Vitals）

WebPerf: Core Web Vitals

JavaScript snippets for measuring web performance in Chrome DevTools. Execute with mcp__chrome-devtools__evaluate_script, capture output with mcp__chrome-devtools__get_console_message.

Scripts

• scripts/CLS.js — Cumulative Layout Shift (CLS)
• scripts/INP.js — Interaction to Next Paint (INP)
• scripts/LCP-Image-Entropy.js — LCP Image Entropy
• scripts/LCP-Subparts.js — LCP Subparts
• scripts/LCP-Trail.js — LCP Trail
• scripts/LCP-Video-Candidate.js — LCP Video Candidate
• scripts/LCP.js — Largest Contentful Paint (LCP)

Common Workflows

Complete Core Web Vitals Audit

When the user asks for a comprehensive Core Web Vitals analysis or "audit CWV":

1. LCP.js - Measure Largest Contentful Paint
2. CLS.js - Measure Cumulative Layout Shift
3. INP.js - Measure Interaction to Next Paint
4. LCP-Subparts.js - Break down LCP timing phases
5. LCP-Trail.js - Track LCP candidate evolution

LCP Deep Dive

When LCP is slow or the user asks "debug LCP" or "why is LCP slow":

1. LCP.js - Establish baseline LCP value
2. LCP-Subparts.js - Break down into TTFB, resource load, render delay
3. LCP-Trail.js - Identify all LCP candidates and changes
4. LCP-Image-Entropy.js - Check if LCP image has visual complexity issues
5. LCP-Video-Candidate.js - Detect if LCP is a video (poster or video element)

CLS Investigation

When layout shifts are detected or the user asks "debug CLS" or "layout shift issues":

1. CLS.js - Measure overall CLS score
2. Layout-Shift-Loading-and-Interaction.js *(pending — available in webperf-interaction skill)*
3. Cross-reference with webperf-loading skill:

- Find-Above-The-Fold-Lazy-Loaded-Images.js (lazy images causing shifts) - Fonts-Preloaded-Loaded-and-used-above-the-fold.js (font swap causing shifts)

INP Debugging

When interactions feel slow or the user asks "debug INP" or "slow interactions":

1. INP.js - Measure overall INP value; call getINP() after interactions, getINPDetails() for full list
2. Interactions.js *(pending — available in webperf-interaction skill)*
3. Input-Latency-Breakdown.js *(pending — available in webperf-interaction skill)*
4. Long-Animation-Frames.js *(pending — available in webperf-interaction skill)*
5. Long-Animation-Frames-Script-Attribution.js *(pending — available in webperf-interaction skill)*

Video as LCP Investigation

When LCP is a video element (detected by LCP-Video-Candidate.js):

1. LCP-Video-Candidate.js - Identify video as LCP candidate
2. Video-Element-Audit.js (from Media skill) - Audit video loading strategy
3. LCP-Subparts.js - Analyze video loading phases
4. Cross-reference with webperf-loading skill:

- Resource-Hints-Validation.js (check for video preload) - Priority-Hints-Audit.js (check for fetchpriority on video)

Image as LCP Investigation

When LCP is an image (most common case):

1. LCP.js - Measure LCP timing
2. LCP-Subparts.js - Break down timing phases
3. LCP-Image-Entropy.js - Analyze image complexity
4. Cross-reference with webperf-media skill:

- Image-Element-Audit.js (check format, dimensions, lazy loading)

1. Cross-reference with webperf-loading skill:

- Find-Above-The-Fold-Lazy-Loaded-Images.js (check if incorrectly lazy) - Priority-Hints-Audit.js (check for fetchpriority="high") - Resource-Hints-Validation.js (check for preload)

Decision Tree

Use this decision tree to automatically run follow-up snippets based on results:

After LCP.js

• If LCP > 2.5s → Run LCP-Subparts.js to diagnose which phase is slow
• If LCP > 4.0s (poor) → Run full LCP deep dive workflow (5 snippets)
• If LCP candidate is an image → Run LCP-Image-Entropy.js and webperf-media:Image-Element-Audit.js
• If LCP candidate is a video → Run LCP-Video-Candidate.js and webperf-media:Video-Element-Audit.js
• Always run → LCP-Trail.js to understand candidate evolution

After LCP-Subparts.js

• If TTFB phase > 600ms → Switch to webperf-loading skill and run TTFB-Sub-Parts.js
• If Resource Load Time > 1500ms → Run:

1. webperf-loading:Resource-Hints-Validation.js (check for preload/preconnect) 2. webperf-loading:Priority-Hints-Audit.js (check fetchpriority) 3. webperf-loading:Find-render-blocking-resources.js (competing resources)

• If Render Delay > 200ms → Run:

1. webperf-loading:Find-render-blocking-resources.js (blocking CSS/JS) 2. webperf-loading:Script-Loading.js (parser-blocking scripts) 3. webperf-interaction:Long-Animation-Frames.js (main thread blocking)

After LCP-Trail.js

• If many LCP candidate changes (>3) → This causes visual instability, investigate:

1. webperf-loading:Find-Above-The-Fold-Lazy-Loaded-Images.js (late-loading images) 2. webperf-loading:Fonts-Preloaded-Loaded-and-used-above-the-fold.js (font swaps) 3. CLS.js (layout shifts contributing to LCP changes)

• If final LCP candidate appears late → Run webperf-loading:Resource-Hints-Validation.js
• If early candidate was replaced → Understand why initial content was pushed down (likely CLS issue)

After LCP-Image-Entropy.js

• If entropy is very high → Image is visually complex, recommend:

- Modern formats (WebP, AVIF) - Appropriate compression - Potentially a placeholder strategy

• If entropy is low → Image may be over-optimized or placeholder-like
• If large file size detected → Run webperf-media:Image-Element-Audit.js for format/sizing analysis

After LCP-Video-Candidate.js

• If video is LCP → Run:

1. webperf-media:Video-Element-Audit.js (check poster, preload, formats) 2. webperf-loading:Priority-Hints-Audit.js (check fetchpriority on poster) 3. LCP-Subparts.js (analyze video loading phases)

• If poster image is LCP → Treat as image LCP (run image workflows)

After CLS.js

• If CLS > 0.1 → Run webperf-interaction:Layout-Shift-Loading-and-Interaction.js *(pending — available in webperf-interaction skill)*
• If CLS > 0.25 (poor) → Run comprehensive shift investigation:

1. webperf-loading:Find-Above-The-Fold-Lazy-Loaded-Images.js (images without dimensions) 2. webperf-loading:Fonts-Preloaded-Loaded-and-used-above-the-fold.js (font loading strategy) 3. webperf-loading:Critical-CSS-Detection.js (late-loading styles) 4. webperf-media:Image-Element-Audit.js (missing width/height)

• If CLS = 0 → Confirm with multiple page loads (might be timing-dependent)

After INP.js

• If INP > 200ms → Run webperf-interaction:Interactions.js to identify slow interactions
• If INP > 500ms (poor) → Run full INP debugging workflow:

1. webperf-interaction:Interactions.js (list all interactions) 2. webperf-interaction:Input-Latency-Breakdown.js (phase breakdown) 3. webperf-interaction:Long-Animation-Frames.js (blocking frames) 4. webperf-interaction:Long-Animation-Frames-Script-Attribution.js (culprit scripts)

• If specific interaction type is slow (e.g., keyboard) → Focus analysis on that interaction type
• After INP data is collected → call getINPDetails() for the full sorted interaction list (useful for identifying patterns across multiple slow interactions)

Error Recovery

• If any script returns status: "error" → Check if the page has finished loading:

- If early in load: wait and re-run the script - If page is an SPA: user may need to navigate to the target route first

• If LCP.js / LCP-Subparts.js returns status: "error" → Tell the user: "LCP data is not available yet. Please ensure the page has fully loaded, then run the analysis again."
• If INP.js getINP() returns status: "error" → The getDataFn: "getINP" field signals the agent can retry after user interaction. Prompt the user to click, type, or scroll, then call getINP() again.

Cross-Skill Triggers

Context fork note: This skill runs with context: fork. Cross-skill triggers below are recommendations to report back to the parent agent, not direct calls this subagent can execute. When a cross-skill trigger fires, tell the user which skill and script to run next. Scripts marked *(pending)* are not yet available — skip them and note the limitation.

These triggers recommend using snippets from other skills:

From LCP to Loading Skill

• If LCP > 2.5s and TTFB phase is dominant → Use webperf-loading skill:

- TTFB.js, TTFB-Sub-Parts.js, Service-Worker-Analysis.js

• If LCP image is lazy-loaded → Use webperf-loading skill:

- Find-Above-The-Fold-Lazy-Loaded-Images.js

• If LCP has no fetchpriority → Use webperf-loading skill:

- Priority-Hints-Audit.js

From CLS to Loading Skill

• If CLS caused by fonts → Use webperf-loading skill:

- Fonts-Preloaded-Loaded-and-used-above-the-fold.js - Resource-Hints-Validation.js (for font preload)

• If CLS caused by images → Use webperf-media skill:

- Image-Element-Audit.js (check for width/height attributes)

From INP to Interaction Skill

• If INP > 200ms → Use webperf-interaction skill for full debugging:

- Interactions.js, Input-Latency-Breakdown.js - Long-Animation-Frames.js, Long-Animation-Frames-Script-Attribution.js - LongTask.js (if pre-interaction blocking suspected)

From LCP/INP to Interaction Skill

• If render delay or interaction delay is high → Use webperf-interaction skill:

- Long-Animation-Frames.js (main thread blocking) - LongTask.js (long tasks delaying rendering)

Multi-Metric Correlation

When multiple CWV metrics are poor, prioritize investigation:

• If LCP > 2.5s AND CLS > 0.1 → Likely shared root cause:

1. Check for late-loading content pushing LCP element 2. Run LCP-Trail.js to see LCP candidate changes 3. Run Layout-Shift-Loading-and-Interaction.js to correlate timing

• If LCP > 2.5s AND INP > 200ms → Main thread congestion:

1. Run Long-Animation-Frames.js 2. Run webperf-loading:Script-Loading.js 3. Run webperf-loading:JS-Execution-Time-Breakdown.js

• If CLS > 0.1 AND INP > 200ms → Layout thrashing or interaction-triggered shifts:

1. Run Layout-Shift-Loading-and-Interaction.js 2. Run Interactions.js 3. Check if shifts occur during/after interactions

References

• references/snippets.md — Descriptions and thresholds for each script
• references/schema.md — Return value schema for interpreting script output