GoogleChrome/lighthouse

This system is Lighthouse, an open-source automated tool for auditing the quality of web pages across performance, accessibility, SEO, and best practices. It provides a modular architecture supporting multiple execution modes—including navigation, timespan, and snapshot—via CLI, Node.js API, and Chrome DevTools integration. Recent updates have expanded its capabilities to include 'Agentic Browsing' audits for AI agent compatibility and a new 'Flow Report' renderer for analyzing multi-step user journeys.

54 changes.

This period focused on migrating the codebase to ES modules, restructuring TypeScript types for better modularity, and replacing the legacy Chrome extension with a PageSpeed Insights-based launcher. Significant effort was also directed toward modernizing the reporting infrastructure, introducing a new Preact-based Flow Report renderer, and adding support for Protocol Buffers and Treemap visualizations.

76 changes.

This period focused on migrating the codebase to ES modules and restructuring the core gatherer architecture with a new driver abstraction and dedicated runners. It also introduced significant new features, including an Agentic Browsing category, expanded accessibility checks via axe-core, and improved byte-efficiency metrics, supported by extensive test infrastructure updates.

17 changes.

This period focused on introducing agentic browsing capabilities, including new audits and gatherers for AI resource discovery (ARD) and LLMs.txt, alongside a major architectural shift to replace legacy performance audits with trace-engine-powered insights. The work also involved modernizing the build system by migrating from Rollup to esbuild and expanding test coverage for these new features and internal tooling.

The changelog generator now uses Handlebars templates (commit.hbs, header.hbs, template.hbs) to structure release notes. These templates define the layout for version headers with comparison links, group commits by category, and format individual commit entries with optional scope, message, and PR/commit hash links.

build/changelog-generator/templates · high confidence

New Preact wrapper components (CategoryScore, Markdown, Report, Styles) are introduced in the flow-report package to embed standard Lighthouse report elements within a flow context. The Report wrapper configures the renderer to disable fireworks and dark mode, omits the top bar and global styles, and converts standard anchor links into flow-specific navigation links that scroll to the corresponding node index. The CategoryScore wrapper handles gather mode and anchor hrefs, while Markdown and Styles provide basic rendering for text and CSS respectively.

flow-report/src/wrappers · high confidence

The build system now includes an inline-fs plugin that statically evaluates and replaces \fs.readFileSync\ and \fs.readdirSync\ calls with their actual file contents during bundling. This optimization is available for both browserify (via \browserifyInlineFs\) and esbuild (via \inlineFsPlugin\), allowing developers to include static assets directly in their bundles without runtime file system access. The plugin supports configuration options such as verbose logging for warnings and ignoring specific paths, and it handles errors for missing files or unparseable expressions gracefully.

build/plugins · high confidence

The \types/internal\ directory now includes a comprehensive set of new \.d.ts\ files that provide TypeScript type definitions for various external dependencies (such as \cssstyle\, \enquirer\, \http-link-header\, \jsonlint-mod\, \lookup-closest-locale\, \pretty-json-stringify\, \typed-query-selector\, and \rxjs\) and internal test utilities (including \smokehouse\, \test\, and \rollup-plugin-postprocess\). These additions ensure strict type checking for internal tooling, browser environment globals, and the smoke test runner without requiring changes to the public API surface.

types/internal · high confidence

A new manual SEO audit has been added to check if structured data on a page is valid. Users are prompted to run the Structured Data Testing Tool to validate their implementation, with links to documentation on structured data and the testing tool itself.

core/audits/seo/manual · high confidence

A new sidebar component has been added to flow reports, providing a navigation panel that lists individual flow steps with links to jump to specific segments, displays a summary link, and shows runtime settings such as device emulation, network throttling, and CPU slowdown multiplier.

flow-report/src/sidebar · high confidence

A new utility script (\download-content-shell.js\) and its supporting utilities have been added to the \third-party\ directory. This tool automatically downloads the Chromium Content Shell binary from Google's snapshot storage, caches it locally (up to 10 versions), and cleans up older shells to save disk space. It is designed to support DevTools integration tests by providing a consistent, cached browser binary for running web tests.

third-party/download-content-shell · high confidence

The treemap application now includes a sample \debug.json\ file in its \app\ directory. This file contains a full Lighthouse HTML Report (LHR) structure for a test run on coursehero.com, including audit results, performance metrics, and screenshot thumbnails. This serves as a concrete data example for the treemap tool to visualize and analyze report data.

treemap/app · high confidence

The Flow Report now includes a dedicated internationalization system, providing a React context provider that merges Lighthouse report strings with new Flow-specific UI labels. This change introduces the English source strings for the report's interface, including labels for report types (Navigation, Timespan, Snapshot), category names, ratings, and a new help dialog explaining how to interpret flow reports. Users will see these localized strings in the report UI, with the system designed to support additional languages via build-time injection.

flow-report/src/i18n · high confidence

The core/lib directory now includes several new utility modules: arbitrary-equality-map.js provides a map implementation with custom equality functions using lodash-es; asset-saver.js handles saving and loading artifacts, traces, and devtools logs to disk with gzip support; axe.js loads the axe-core accessibility library source; bf-cache-strings.js contains auto-generated strings for back/forward cache deprecation reasons; csp-evaluator.js evaluates Content Security Policies for security issues; deprecation-description.js and deprecations-strings.js handle browser API deprecation warnings; emulation.js manages user agent and device emulation settings; icons.js provides utilities for checking manifest icons; and lantern-trace-saver.js converts simulation timings to trace format for debugging.

core/lib · high confidence

The accessibility audit suite has been significantly expanded with the addition of numerous new checks, including validations for unique access keys, ARIA attribute and role correctness (allowed attributes, prohibited attributes, required attributes/children/parents, valid values, and deprecated roles), accessible naming for various ARIA elements (buttons, dialogs, inputs, meters, progress bars, toggles, tooltips, tree items, and text elements), and proper use of the autocomplete attribute. These new audits are implemented via a refactored \AxeAudit\ base class that standardizes how axe-core rule results are processed and reported, ensuring consistent handling of violations, incomplete results, and informative-only checks across the entire accessibility section.

core/audits/accessibility · high confidence

Added a JavaScript-based conformance testing tool for the Agentic Resource Discovery (ARD) specification, ported from the upstream Python reference implementation. This new validation suite enforces strict JSON Schema compliance for AI catalog manifests and applies custom semantic checks, including validation of RFC 8141 URN identifiers, required fields (such as \specVersion\, \entries\, \displayName\, and \type\), and media type standards. The implementation features a precompiled standalone schema validator to ensure compatibility with Content Security Policy (CSP) restrictions in browser environments, and includes a comprehensive test suite to verify adherence to the specification.

third-party/ard · high confidence

A new suite of insight audits has been added to the core/audits/insights directory, replacing several legacy audits with more detailed, trace-engine-powered diagnostics. These include cache-insight (replacing uses-long-cache-ttl), cls-culprits-insight (replacing layout-shifts), document-latency-insight (replacing redirects, server-response-time, uses-text-compression), dom-size-insight (replacing dom-size), duplicated-javascript-insight (replacing duplicated-javascript), font-display-insight (replacing font-display), image-delivery-insight (replacing modern-image-formats, uses-optimized-images, efficient-animated-content, uses-responsive-images), inp-breakdown-insight (replacing work-during-interaction), lcp-breakdown-insight (replacing largest-contentful-paint-element), lcp-discovery-insight (replacing prioritize-lcp-image, lcp-lazy-loaded), legacy-javascript-insight, modern-http-insight, network-dependency-tree-insight (replacing critical-request-chains, uses-rel-preconnect), render-blocking-insight (replacing render-blocking-resources), and third-parties-insight (replacing third-party-summary). Each audit leverages the trace engine to provide deeper insights, such as specific culprits for layout shifts, detailed LCP breakdowns, and network dependency trees with preconnect advice. The insight-audit.js helper standardizes how these audits process trace engine results, handle metric savings, and format output for the report.

core/audits/insights · high confidence

The report module now exposes a new API surface via extracted type definitions, allowing clients to configure the HTML report renderer with granular control. Users can now disable dark mode and fireworks animations, omit the topbar or global styles, and configure the report to occupy the entire viewport. Additionally, new callbacks allow customizing the 'Save as HTML' behavior, overriding print actions, and handling 'View Trace' button clicks, while flow reports can customize anchor link rendering.

report/types · high confidence

Adds the foundational assets for the new standalone Flow Report, including a standalone HTML template that injects report data and JavaScript, and a comprehensive CSS stylesheet defining the layout (grid-based topbar, sidebar, and content areas), typography, and UI components like the sidebar navigation and topbar buttons.

flow-report/assets · high confidence

The flow-report module now provides a standalone HTML report renderer built with Preact. A new API entry point (api.ts) exposes renderFlowReport to mount the report UI into a specified DOM element, while a standalone client (clients/standalone.ts) automatically initializes this renderer within the report HTML by querying the main container and injecting the flow result data. The module is configured via a dedicated tsconfig.json that sets up Preact JSX support and references the necessary Lighthouse type definitions.

flow-report · high confidence

Adds the CSS styles for the new treemap report view, defining a two-column grid layout that displays the treemap visualization on the left and a data table on the right. The styles include a header with URL and input controls, specific typography and color variables for text and buttons, and visual elements for table rows, separators, and coverage bars.

treemap/app/styles · high confidence

Adds a new type declaration file (flow-report.d.ts) that defines the global types and interfaces required for the Flow Report feature. This includes exposing the FlowResult type, ConfigSettings, and the FlowReportOptions interface (with methods for getting HTML and saving as a gist) within the LH namespace, as well as augmenting the Window interface with \_\_LIGHTHOUSE\_FLOW\JSON\\_ and \_\initLighthouseFlowReport\\_ to support strict type checking for the standalone shell report.

flow-report/types · high confidence

This change adds the \treemap/types/treemap.d.ts\ file, which establishes the TypeScript type declarations for the Treemap feature. It exposes the \LH\ namespace with types for Treemap, Result, Locale, and FlowResult, and defines the \WebTreeMap\ class and its associated options and render state interfaces. This enables strict type checking and better IDE support for developers working with the treemap visualization logic.

treemap/types · high confidence

A new type declaration file (viewer/types/viewer.d.ts) has been added to define the global variables and interfaces exposed by the viewer application. This includes the ReportGenerator, logger, and the main LighthouseReportViewer instance attached to the window object, along with necessary imports for DOM augmentation, HTML rendering, and flow reports. This change provides static typing support for developers interacting with the viewer's public API.

viewer/types · high confidence

The \core/gather/driver\ directory now includes several new JavaScript modules that implement core driver functionality. \dom.js\ provides utilities to resolve backend node IDs and DevTools node paths to object IDs for runtime evaluation. \environment.js\ adds logic to detect slow host CPUs and compute device pixel ratio, emitting warnings when the host device is underpowered. \navigation.js\ handles page navigation, including redirect detection and timeout warnings. \network-monitor.js\ tracks network requests to determine idle states, treating EventSource as non-critical. \prepare.js\ manages target preparation, including enabling async stacks, dismissing JavaScript dialogs, and resetting storage. \storage.js\ handles clearing origin data and browser caches with timeout warnings. \target-manager.js\ tracks multiple targets (pages, iframes, workers) and manages protocol sessions. \wait-for-condition.js\ implements waiting logic for FCP, network idle, and CPU idle states. \execution-context.js\ manages isolated execution contexts for page evaluation. \network.js\ fetches response bodies from cache. These changes collectively enhance the driver's ability to manage browser state, track performance metrics, and handle navigation robustly.

core/gather/driver · high confidence

This change introduces the \lighthouse-result.proto\ file, which defines the Protocol Buffer schema for the Lighthouse Result (LHR) object, and a \README.md\ with instructions for compiling and using the protos. The proto definition maps the LHR structure, including \LighthouseResult\, \AuditResult\, \ConfigSettings\ (with \ThrottlingSettings\), and the \LighthouseError\ enum, enabling structured serialization and round-trip conversion of Lighthouse audit data.

proto · high confidence

A new validation suite in core/scripts/legacy-javascript has been introduced to ensure the LegacyJavaScript audit accurately detects polyfills for Baseline web features. This tool generates various code variants using different bundlers (Browserify, esbuild, Rollup) and transpilers, then verifies that the audit correctly identifies the presence or absence of specific polyfills. It produces summary data (summary-signals.json, summary-sizes.txt) to track detection coverage and polyfill sizes, helping prevent regressions in the audit's ability to flag unnecessary legacy code.

core/scripts/legacy-javascript · high confidence

The Lightrider client now provides a new \lightrider-entry.js\ that bundles the core Lighthouse API, presets, and utilities for use in browser environments. This entry point exposes \runLighthouseInLR\ for executing audits, \listenForStatus\ for monitoring progress, and \computeBenchmarkIndex\ for performance metrics. It also handles locale registration, error serialization, and asset logging, ensuring compatibility with CommonJS consumers while supporting modern ES module usage.

clients/lightrider · high confidence

Added two new gatherers to support AI agent integration: AgentResourceDiscovery (ard.js) and LlmsTxt (llms-txt.js). The AgentResourceDiscovery gatherer locates AI catalog resources by checking the robots.txt 'Agentmap' directive, HTML link tags with rel='ai-catalog', HTTP Link headers, and the standard /.well-known/ai-catalog.json path, then fetches the resolved catalog URL. The LlmsTxt gatherer fetches the /llms.txt file from the site root. Both gatherers support snapshot and navigation modes and provide detailed discovery signals and error messages to help users understand how AI agents can discover and access their site's resources.

core/gather/gatherers/agentic · high confidence

Lighthouse introduces a new 'Agentic Browsing' category designed to help developers optimize their websites for AI agents. This category includes audits for WebMCP integration correctness, agent accessibility best practices, and agent discoverability (such as LLMs.txt and Agent Resource Discovery schemas). The configuration is available as a standalone config (\agentic-browsing-config.js\) that extends the default Lighthouse config, allowing users to run these specific checks alongside or instead of standard performance and accessibility audits.

core/config · high confidence

The report/clients directory now provides dedicated entry points for rendering Lighthouse reports in different contexts. A new bundle.js file exports core rendering components (DOM, ReportRenderer, ReportUIFeatures, renderReport) and localization utilities for use in ES module codebases, allowing embedders to integrate the report renderer directly. Additionally, a new standalone.js file serves as the entry point for the standalone HTML report, initializing the report from the global \_\_LIGHTHOUSE\JSON\\_ variable, configuring the renderer to occupy the entire viewport, and setting up event listeners for analytics and logging.

report/clients · high confidence

Added a new suite of scripts in core/scripts/gcp-collection to automate running Lighthouse audits across a fleet of Google Cloud Platform instances. The collection includes fleet management tools (fleet-create.sh, fleet-status.sh, fleet-destroy.sh) to provision, monitor, and terminate VMs, along with setup and execution scripts (gcp-setup.sh, gcp-run.sh, gcp-run-on-url.sh) to configure the environment and run audits. An analysis script (analyze-lhr-data.js) and data extraction utility (extract-data.sh) are also provided to aggregate and process the resulting Lighthouse results, supported by a sample URL list and documentation.

core/scripts/gcp-collection · high confidence

Added a new script suite in core/scripts/lantern/collect to gather and process web performance traces from WebPageTest and local runs. This tool collects Lighthouse results and traces for a curated list of popular sites, allowing developers to generate a 'golden' dataset of median performance runs used to calibrate the Lantern performance model.

core/scripts/lantern/collect · high confidence

A new gatherer has been added to the SEO module to fetch and analyze the site's robots.txt file. This component now utilizes the \finalDisplayedUrl\ from the URL artifact to construct the correct request path, ensuring accuracy across redirects. Additionally, the gatherer includes specific error handling: if the fetch operation fails, it logs the error and returns a structured result containing the error message, rather than failing silently or throwing an unhandled exception.

core/gather/gatherers/seo · high confidence

Three new Lighthouse audits have been added to the agentic browsing suite to help developers optimize their sites for AI agents. The \agent-accessibility-tree\ audit checks that the page's accessibility tree is well-formed by validating specific ARIA rules, ensuring AI agents can navigate and interact with the content. The \ard-schema\ audit validates the \ai-catalog.json\ manifest against the Agentic Resource Discovery (ARD) specification, which is required for autonomous agents to discover and verify resources. Finally, the \llms-txt\ audit verifies that the \llms.txt\ file follows community recommendations, such as containing a required H1 header and links, to ensure large language models can correctly understand how the site should be crawled or used for training.

core/audits/agentic · high confidence

This update introduces several new audits and refines existing ones within the 'Do Better Web' section. A new 'Paste-preventing inputs' audit now flags input fields that block pasting, which harms accessibility and security. The 'Doctype' audit has been enhanced to detect limited quirks-mode issues using trace data, and the 'Inspector issues' audit now reports a broader set of problems including blocked-by-response and heavy ad issues. Additionally, new audits check for proper charset declaration, geolocation permission requests on page load, and notification permission requests on page load, while the JavaScript libraries audit remains an informative diagnostic.

core/audits/dobetterweb · high confidence

The build system now includes new scripts to generate a precompiled standalone schema validator for the AI Catalog (build-ard-schema.js), a subset of web-features baseline data for bundle size optimization (build-baseline-data.js), and a specialized Lighthouse bundle for Chrome DevTools MCP that includes accessibility, SEO, best practices, and agentic browsing audits (build-bundle-mcp.js).

build · high confidence

This change introduces a suite of new scripts in the core/scripts directory to support development, testing, and internal analysis workflows. Key additions include scripts for asserting baseline flow and Lighthouse result stability (assert-baseline-flow-result-unchanged.sh, assert-golden-lhr-unchanged.sh), generating insight audits (generate-insight-audits.js), and analyzing GitHub issue response times (internal-analysis/download-issues.js, internal-analysis/analyze-issues.js). It also adds utilities for benchmarking (benchmark.js, benchmark-plus-extras.js), debugging full-page screenshots (full-page-screenshot-debug.js), and building/running DevTools with the current Lighthouse integration (build-devtools.sh, open-devtools.sh, pptr-run-devtools.js).

core/scripts · high confidence

The flow report now includes a dedicated summary page that displays a high-level overview of all flow steps. This view features a header indicating the count of navigation, timespan, and snapshot reports, followed by a list of steps. Each step shows a thumbnail, the gather mode, and a link to the detailed view. Crucially, each step includes category scores (Performance, Accessibility, Best Practices, SEO) with interactive tooltips. These tooltips provide detailed breakdowns, including the number of passed/passable/informative audits, the category rating, and the top two highest-impact audits contributing to the score, helping users quickly identify areas for improvement across their entire flow.

flow-report/src/summary · high confidence

The \core/gather/gatherers\ directory now includes new gatherers that expand Lighthouse's data collection capabilities. The \Accessibility\ gatherer runs axe-core checks to identify WCAG violations and incomplete issues. The \BFCacheFailures\ gatherer actively and passively detects back-forward cache restoration failures to help diagnose navigation issues. The \FullPageScreenshot\ gatherer captures a complete screenshot of the page, handling viewport resizing and network idle waits to ensure all content is rendered. Additionally, new gatherers for \AnchorElements\, \ConsoleMessages\, \CSSUsage\, \DevtoolsLog\, \IFrameElements\, \ImageElements\, \Inputs\, \InspectorIssues\, \JsUsage\, and \LinkElements\ provide detailed artifacts on DOM structures, console logs, style usage, and protocol events, forming the foundation for more comprehensive performance and accessibility audits.

core/gather/gatherers · high confidence

The core/lib/i18n directory now contains the i18n.js module and README.md, introducing a new internationalization pipeline. This module defines shared UI strings (UIStrings) using ICU message syntax for placeholders, plurals, and selects, and provides a createIcuMessageFn function to generate localized messages. It also includes a lookupLocale function that resolves the best available locale by checking exact matches, prefix fallbacks, and Intl formatter support, falling back to the default locale if necessary.

core/lib/i18n · high confidence

This change introduces ten new manual accessibility audits in the core accessibility suite, providing specific checks for custom controls (labels and ARIA roles), focus management (focus traps, logical tab order, managed focus, and focusable controls), and structural landmarks (use of HTML5 landmark elements, offscreen content hiding, and visual order matching DOM order). These audits guide users to manually verify that interactive elements are properly labeled, keyboard navigation is logical and trap-free, and assistive technologies can correctly interpret page structure and hidden content.

core/audits/accessibility/manual · high confidence

The report assets now include a new standalone HTML template (standalone-template.html) that serves as the entry point for Lighthouse reports, embedding the report JSON and JavaScript directly into the page. This is accompanied by a comprehensive styles.css file defining CSS variables for theming (including dark mode support) and layout, as well as templates.html containing the HTML structure for report components like audits, metrics, and gauges. These changes establish the foundational structure for rendering Lighthouse reports in a standalone browser context.

report/assets · high confidence

The viewer application now allows users to authenticate with GitHub and save Lighthouse reports directly to private Gists, with the option to load those reports later via a URL deep link. This change introduces a new drag-and-drop file interface, integrates Firebase Authentication for GitHub sign-in, and adds logic to handle gist creation and retrieval, including caching and rate-limit awareness. Additionally, the viewer can now load reports from a JSON URL or the PageSpeed Insights API, and it persists the dark mode setting when the language is changed.

viewer/app/src · high confidence

The \helpers/test-loader.js\ module has been removed. This file previously provided a utility for recursively walking directories to discover and load test definitions from \package.json\ files. Its removal indicates a shift in how tests are discovered or loaded within the project, likely simplifying the test infrastructure or moving this logic elsewhere.

helpers · high confidence

The Lighthouse Report (LHR) TypeScript definitions have been restructured into separate, independent modules (audit-details, audit-result, flow-result, i18n, lhr, settings, treemap) to support direct import and publishing. This change introduces new type structures including \metricSavings\ on audit results, \errorStack\ exposure for runtime errors, entity classification data in the LHR, and a dedicated \FlowResult\ type for user flows. It also deprecates legacy fields like \finalUrl\ and \overallSavingsMs\ while adding support for new detail types such as \NetworkTree\ and \Checklist\.

types/lhr · high confidence

The core/gather module has been restructured to introduce a new execution model for Lighthouse audits. This change introduces a new \Driver\ class that abstracts browser communication, a \Fetcher\ utility for resource collection, and a \ProtocolSession\ wrapper that handles Chrome DevTools Protocol commands and crash detection. The previous legacy runner logic is replaced by three distinct entry points: \navigation-runner.js\ for full page load audits, \timespan-runner.js\ for user interaction timing, and \snapshot-runner.js\ for static page analysis. These runners coordinate with new helper modules (\runner-helpers.js\) to manage artifact collection phases and a new \base-artifacts.js\ module to standardize the creation and finalization of audit data.

core/gather · high confidence

The report/renderer directory has been restructured into a modular, ES-module-based architecture. A new public API entry point (api.js) exposes functions like renderReport and renderCategoryScore, replacing the previous monolithic rendering approach. The renderer is now split into distinct components: CategoryRenderer handles audit and category display, DetailsRenderer manages specific audit detail types (tables, lists, filmstrips), and specialized renderers (e.g., CriticalRequestChainRenderer, ElementScreenshotRenderer) handle complex visualizations. This change decouples the rendering logic, making the report generation more maintainable and allowing for easier integration of new detail types or UI features.

report/renderer · high confidence

The \types/\ directory has been restructured to support direct import and publishing of Lighthouse's TypeScript definitions. The previous \externs.d.ts\ file has been replaced by dedicated, modular type definition files (\artifacts.d.ts\, \audit.d.ts\, \config.d.ts\, \gatherer.d.ts\, \protocol.d.ts\, \puppeteer.d.ts\, \user-flow.d.ts\, and \utility-types.d.ts\), which are then re-exported through a unified \lh.d.ts\ entry point. This change consolidates the type hierarchy under the \LH\ namespace, making the public API more explicit and easier to consume for plugin developers and external consumers.

types · high confidence

The core/lib/cdt module now uses minimal Apache-2.0 license headers across its files. New Common.js and Platform.js files are introduced to expose ParsedURL and array utility functions (lowerBound, upperBound) respectively, aligning with the Chrome DevTools frontend structure. Additionally, SDK.js now includes a patch to SourceMap that adds lastColumnNumber to mappings, improving source map resolution accuracy for users.

core/lib/cdt · high confidence

The core audit system has been migrated to ES modules and now supports a new METRIC\_SAVINGS scoring mode, allowing audits like bootup-time to report specific time savings (e.g., TBT) alongside their primary metrics. The base Audit class now includes helper methods for generating checklist and table details, and enforces heading key validation during tests to prevent display errors.

core/audits · high confidence

The byte-efficiency audits (Total Byte Weight, Unminified CSS/JS, Unused CSS/JS) now estimate the impact of reducing network payloads on key performance metrics, specifically First Contentful Paint (FCP) and Largest Contentful Paint (LCP). The base \ByteEfficiencyAudit\ class uses Lantern graphs to simulate these savings, and the audit results now include \metricSavings\ for FCP and LCP. Additionally, the scoring for wasted time has been updated to use a log-normal distribution, and the audits now exclude header size when estimating wasted bytes for JavaScript.

core/audits/byte-efficiency · high confidence

The CLI command modules in the \cli/commands\ directory have been migrated from CommonJS to ES modules, utilizing \import\ and \export\ syntax. This change includes the adoption of standardized minimal license headers across the files. The specific commands \listAudits\, \listLocales\, and \listTraceCategories\ now export their functionality as ES module exports, ensuring compatibility with the project's broader shift to ES module architecture.

cli/commands · high confidence

The CLI has been refactored from a single entry point into a modular structure (bin.js, cli-flags.js, run.js, printer.js, sentry-prompt.js) that separates argument parsing, Chrome launching, and report writing. Users can now list available audits, locales, and trace categories using dedicated flags. The printer now supports writing output to files (creating directories as needed) and stdout, with HTML reports optionally opening in the browser via --view. Error reporting to Sentry is now opt-in, prompting users for permission on first run unless overridden by --enable-error-reporting or --no-enable-error-reporting. The CLI also validates precomputed Lantern data and enforces that x64 Node on Mac arm64 throws an error to prevent performance issues.

cli · high confidence

The \core/computed\ module has been refactored to use a new \makeComputedArtifact\ wrapper that automatically caches results and strictly validates that all required dependency properties are present. This change prevents silent failures from missing or undefined dependencies by throwing errors in tests and logging errors in production. Additionally, several computed artifacts have been updated to use the new \DocumentUrls\ artifact for URL resolution, and the \EntityClassification\ artifact now classifies Chrome extensions into separate entities.

core/computed · high confidence

The core module has been restructured to expose a unified entry point (index.js/index.cjs) that centralizes the public API, including navigation, snapshot, timespan, and user-flow methods, alongside the report generator and configuration exports. A new ManualAudit base class has been added to simplify the creation of audits requiring user verification, automatically handling the manual scoring mode. Additionally, a Doctype gatherer has been introduced to capture document type and compatibility mode information for use in audits.

core · high confidence

The \core/computed/metrics\ module has been refactored to compute observed performance metrics (such as Cumulative Layout Shift, First Contentful Paint, Largest Contentful Paint, and Time to First Byte) directly from the raw trace using the new Trace Engine, rather than relying on the previous \ProcessedNavigation\ artifact. This change introduces a new \TraceEngineResult\ computed artifact and updates metric implementations to derive timing and timestamp data from trace events, ensuring consistency between simulated and observed metric calculations.

core/computed/metrics · high confidence

The DevTools entry point has been migrated to ES modules, replacing the previous CommonJS-style bundle with a modern module structure. This change explicitly exposes core Lighthouse capabilities—such as navigation, timespan, and snapshot modes, along with configuration and locale utilities—to the DevTools frontend environment, while also ensuring compatibility with bundlers by explicitly importing the Buffer polyfill.

clients/devtools · high confidence

The extension popup UI has been updated to allow users to select the report generation backend (switching between the PSI Frontend and the Lighthouse Viewer) and to choose a specific locale for the audit results. The settings controller now persists these new options alongside device and category preferences, and the popup displays localized language-region labels for the available locales.

clients/extension/scripts · high confidence

The \core/lib/tracehouse\ directory now contains the core logic for parsing and analyzing browser traces. This includes \cpu-profile-model.js\ to convert V8 CPU profiler sampling data into trace events, \main-thread-tasks.js\ to build hierarchical task trees from raw trace events, \task-groups.js\ to classify tasks (e.g., Script Evaluation, Rendering), \task-summary.js\ to attribute task execution to specific URLs, and \trace-processor.js\ to extract key navigation and paint metrics. This refactoring centralizes trace processing capabilities previously scattered across the codebase.

core/lib/tracehouse · high confidence

A new entry point file (devtools-mcp-entry.js) has been added to the clients/devtools-mcp directory. This file re-exports the navigation, snapshot, and generateReport modules from the core index, effectively bundling these agentic browsing features for use by the devtools-mcp client.

clients/devtools-mcp · high confidence

The flow report view has been replaced with a new implementation built on Preact. This change introduces a dedicated application shell (\App\) that manages the layout via a sidebar, topbar, and content area, replacing the previous rendering approach. The new UI includes a summary page for the overall flow, a header component displaying animated filmstrip thumbnails for navigation steps, and a help dialog that explains the different report modes (navigation, timespan, snapshot) to users. Context providers are used to pass the flow result and report options through the component tree, enabling features like hash-based navigation and localized strings.

flow-report/src · high confidence

The \core/scripts/lantern\ directory now includes a suite of scripts to manage and validate Lantern metric baselines. \assert-baseline-lantern-values-unchanged.js\ compares computed Lantern values against a stored baseline to detect regressions, while \update-baseline-lantern-values.js\ generates new baseline data by running the Lantern engine on all assets. Supporting scripts like \run-on-all-assets.js\ and \run-once.js\ handle the execution of the engine against trace and devtools log data, and \constants.js\ centralizes the paths and evaluation logic for these metrics.

core/scripts/lantern · high confidence

The Lantern module in core/lib/lantern has been updated to serve as a re-export layer for the Trace Engine. It now exposes all models from the Trace Engine's lantern module and aliases the LanternComputationData type as TraceEngineComputationData, effectively shifting the implementation source to the Trace Engine while maintaining the public API surface for consumers.

core/lib/lantern · high confidence

The legacy-javascript analysis tool has been refactored to import its polyfill and graph data from local JSON files (\polyfill-module-data.json\ and \polyfill-graph-data.json\) using ES module \with { type: 'json' }\ import attributes. This change moves the polyfill definitions and size estimation data out of the JavaScript source code and into dedicated data files, allowing the tool to identify unnecessary polyfills and transforms more efficiently based on Baseline browser support.

core/lib/legacy-javascript · high confidence

The Lighthouse browser extension has been retired and replaced with a new launcher that utilizes the PageSpeed Insights (PSI) API. This change is evident in the new manifest.json which defines a Manifest V3 extension and the new popup.html which features a 'Generate report' button and a disclaimer stating it uses the PSI API. Users will no longer run full Lighthouse audits locally within the browser but will instead generate reports via the remote PSI service, with specific guidance provided for Chrome DevTools and Node CLI usage for local or authenticated sites.

clients/extension · high confidence

The lighthouse-logger package has been upgraded to version 2.0.2, converting the module from CommonJS to ES modules and adding TypeScript type definitions. This change introduces new \time()\ and \timeEnd()\ methods for performance timing, a \warn\ logging level, and an \isVerbose()\ utility, while also adding an Apache 2.0 license file and updating the README.

lighthouse-logger · high confidence

The core performance metrics (Cumulative Layout Shift, First Contentful Paint, Interaction to Next Paint, Time to Interactive, Largest Contentful Paint, Max Potential FID, Speed Index, and Total Blocking Time) have been updated to require the new \Trace\ and \DevtoolsLog\ artifacts instead of the legacy \devtoolsLogs\ and \traces\ formats. This change aligns the metric audits with the broader migration to the unified artifact system, ensuring consistent data access and enabling features like enhanced traces and source map support for more accurate performance reporting.

core/audits/metrics · high confidence

The i18n workflow now includes a new \assert-strings-collected.sh\ script that runs \collect-strings.js\ and fails the build if UI strings or locale files have changed without being committed. The collection process has been updated to support reusing the same placeholder for ICU messages and to handle string placeholder collisions, ensuring translators receive consistent and valid input. Additionally, obsolete translation messages are now automatically pruned from locale files if they no longer exist in the source or if their ICU arguments have changed, and a new utility counts translation coverage across locales.

core/scripts/i18n · high confidence

The shared/localization directory now contains a new, unified i18n implementation. This includes a format module that uses \intl-messageformat\ to handle ICU message syntax and custom number/date formatting, a locales module that imports translation JSON files as ES modules, and a swap-locale module that allows dynamically changing the locale of a Lighthouse Result (LHR) object by replacing strings based on pre-calculated ICU message paths. This replaces previous localization logic with a more robust, standardized approach supporting a wider range of locales and better handling of formatted values.

shared/localization · high confidence

The \core/lib/traces\ module has been renamed from \pwmetrics-events\ to \metric-trace-events\ to better reflect its purpose. Additionally, the \first-meaningful-paint\ metric has been removed from the list of synthesized trace events, meaning this specific performance metric will no longer be included in the generated trace data for downstream consumers.

core/lib/traces · high confidence

The build system has switched from using Rollup to esbuild for bundling. This change introduces a new \esbuild-polyfills.js\ module that provides Node.js built-in polyfills specifically for the esbuild pipeline, replacing the previous Rollup-based approach. The new plugin handles module resolution and loading for Node built-ins within esbuild, ensuring compatibility for code relying on these standard libraries.

third-party/esbuild-plugins-polyfills · high confidence

The report generator has been converted to ES modules and restructured into dedicated files (report-generator, report-assets, flow-report-assets, file-namer) to improve maintainability. This change introduces support for generating reports from user flows, including a new HTML template and asset handling for flow-specific styles and scripts. The CSV output has been refactored to include new metadata fields like \finalDisplayedUrl\ and \gatherMode\, and explicitly throws an error when attempting to generate CSV for flow results, as this format is not supported for multi-step flows.

report/generator · high confidence

The SEO audit logic in core/audits/seo has been updated to improve accuracy and coverage. The canonical audit now strictly validates URLs, flagging invalid, relative, conflicting, or root-pointing canonical links. The crawlable-anchors audit has been refined to correctly identify placeholder anchor elements (those with no href but no listeners) as valid, while still catching truly uncrawlable links. Additionally, the robots-txt audit now recognizes the \Content-Signal\ directive as valid, preventing false positives for sites using this non-standard but widely used directive.

core/audits/seo · high confidence

A new shared type definition file exposes core localization and result types (such as IcuMessage, Locale, Result, and FlowResult) within the global LH namespace. This allows both the core library and report modules to reference these types consistently without duplicating definitions, facilitating shared localization logic across the application.

shared/types · high confidence

The shared directory has been converted to ES modules, introducing new files such as \esm-utils.js\ for module path resolution, \root.js\ for locating the project root and version, and \statistics.js\ for score calculations. This migration replaces the previous CommonJS structure (e.g., \util.cjs\) with modern import/export syntax, ensuring consistent module handling across the codebase.

shared · high confidence

The release workflow in core/scripts/release has been refactored to streamline version bumps and packaging. The new bump-versions.js script uses Node.js native replaceAll for updating version strings in package.json, markdown, and test fixtures, replacing older methods. The prepare-commit.sh script now explicitly checks out from the main branch and integrates changelog generation and contributor updates into a single automated step. Additionally, a new package-test.sh script was added to validate the packaged npm package in a pristine environment, ensuring the release artifact works correctly before distribution.

core/scripts/release · high confidence

The treemap application has been updated to prioritize transfer size (compressed) over raw resource size when the underlying report data includes encoded byte counts, ensuring size metrics reflect actual network usage. Additionally, the app now respects an initial view mode passed via options, allowing the interface to open in a specific state (such as a particular table sort or view mode) rather than always resetting to a default, and it dynamically hides the 'unused bytes' view mode if the report data does not contain unused byte information.

treemap/app/src · high confidence

The \valid-langs.js\ module used by the \href\ audit has been updated with the latest valid ISO 639-1/2 language codes. This change ensures that language attribute checks in audits reflect the current IANA language subtag registry, improving the accuracy of accessibility reports for internationalized content.

third-party/axe · high confidence

The viewer application's landing interface has been updated to include a new placeholder screen with instructions for loading reports via drag-and-drop, file selection, or Gist URL, along with a direct link to the Lighthouse Report Diff tool. The visual design now features a dedicated drop zone with feedback, updated logo assets, and responsive CSS adjustments for mobile and desktop views, while also hiding the 'open-viewer' option and ensuring the 'save-gist' option is visible in the tools dropdown.

viewer/app · high confidence

Add JSDOM-based test environment setup for flow-report; Added DevTools e2e test infrastructure; Added DoBetterWeb test fixtures for smoke testing; Added Jest snapshots for performance metrics, predictive performance, and script treemap audits; Added Lighthouse e2e test resources for DevTools; Added SEO test fixtures for link text and crawlability edge cases; Added WebMCP smoke test fixture; Added accessibility test fixtures for new and existing audits; Added bundle rendering test for Lighthouse report; Added byte-efficiency test fixtures; Added comprehensive test coverage for CLI flag parsing and execution; Added end-to-end API tests for Lighthouse modes and user flows; Added end-to-end tests for Lighthouse integration in DevTools; Added faux PageSpeed Insights report template for testing multi-report rendering; Added performance test fixtures for animations, fonts, and layout shifts; Added script to validate Lighthouse Result JSON round-tripping via Protocol Buffers; Added smoke test runners for CLI, DevTools, bundle, and MCP execution modes; Added snapshot tests for FCP, TTI, and Max Potential FID metrics; Added source map fixture for CourseHero bundle; Added test coverage for byte-efficiency audits; Added test coverage for core audit logic and specific audit implementations; Added test coverage for core performance metrics; Added test coverage for driver gather modules; Added test fixtures for ARD and llms.txt E2E scenarios; Added test fixtures for CSS change user flows; Added test fixtures for Lighthouse config plugins; Added test fixtures for Lighthouse v12 compatibility and Lantern accuracy baselines; Added test fixtures for user flow scenarios; Added test fixtures for user flow scenarios; Added test fixtures for user flows and trace generation; Added test to verify inspector issue types match Chromium protocol; Added tests for DoBetterWeb audits; Added tests for Lighthouse Treemap; Added tests for Lighthouse bundle builds and page function bundling; Added tests for core computed artifacts; Added tests for core library utilities; Added tests for i18n string collection and placeholder baking scripts; Added tests for report generator and file-naming utilities; Added tests for shared statistics and utility functions; Added tests for the Agent Resource Discovery (ARD) gatherer; Added tests for the LightRider entry point; Added tests for the Lighthouse Chrome extension popup and settings controller; Added tests for the flow report UI components; Added tests for the flow report sidebar components; Added tests for the inline-fs build plugin; Added tests for the new gather infrastructure and runners; Added tests for the shared localization formatting and locale swapping logic; Added tests for tracehouse CPU profile, main thread task, and trace processing models; Added unit and integration tests for the Lighthouse Viewer; Added unit tests for CategoryScore and Markdown wrappers; Added unit tests for accessibility audit implementations; Added unit tests for agentic accessibility, ARD schema, and llms.txt audits; Added unit tests for core performance metric audits; Added unit tests for the new config system; Added unit tests for the report renderer components; Configurable smoke test exclusions per runner; Expanded test coverage for core Lighthouse components; Expanded test fixtures for Lighthouse audit validation; New test environment setup with custom matchers and snapshot support; New test infrastructure scripts for fixture regeneration and parallel Mocha execution; Removed legacy test infrastructure and specific audit tests; Smokehouse test definitions updated for accessibility, byte efficiency, and new audits; Smokehouse test runner infrastructure and core test suite; Smokehouse test runner refactoring and CLI updates; Updated API test snapshots to reflect new audit coverage; Updated sample test artifacts to Lighthouse v13.5.0; Updated snapshot for Cumulative Layout Shift assertion testing; Updated snapshot for axe-core report renderer test.

This change introduces several new package.json files to support internal tooling and documentation. A new \legacy-javascript\ package is added under \core/lib/\ to identify legacy polyfills and code transforms, while a corresponding build script directory at \core/scripts/legacy-javascript\ includes development dependencies like Babel, Rollup, and esbuild. A temporary CommonJS marker is added for the CDT library. Additionally, new package manifests are created for documentation recipes (auth, custom-audit, custom-gatherer-puppeteer, integration-test, plugin-example, type-checking) to define their specific dependencies and scripts, and a test fixture for a simple Lighthouse plugin is added. The \tests/minify-html\ package is removed.

(dependencies) · high confidence

The core/lib/cdt/generated directory has been updated with the latest Chrome DevTools Frontend packages. This brings in new or refreshed generated JavaScript files, including ParsedURL.js and SourceMap.js, which provide updated utilities for URL normalization and source map parsing. Users benefit from improved compatibility with the latest Chrome DevTools Protocol features and bug fixes included in the upstream CDT codebase.

core/lib/cdt/generated · high confidence

The repository is initialized with essential configuration files including a Code of Conduct, ESLint rules, commitlint and commitizen settings, editorconfig, and npmignore rules. Documentation is established via a comprehensive README and a changelog covering versions up to 13.5.0, while build infrastructure is configured with a build-tracker config and CI coverage settings.

(repo-wide) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 26 → 61 (+35.9)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 53 → 79 (+25.5)
• Architecture 47 → 70 (+22.8)
• Maturity 59 → 74 (+15.0)
• Readiness 14 → 57 (+42.3)
• Security 20 → 68 (+48.3)
• Accessibility 60 (new)

• (anonymous) (cognitive 16) (core/audits/non-composited-animations.js)
• (anonymous) (cognitive 19) (report/renderer/explodey-gauge.js)
• (anonymous) (cyclomatic 16) (report/renderer/explodey-gauge.js)
• Change coupling: app.tsx ↔ util.ts (flow-report/src/app.tsx)
• Change coupling: common.tsx ↔ summary.tsx (flow-report/src/common.tsx)
• Change coupling: create-polyfill-size-estimation.js ↔ run.js (core/scripts/legacy-javascript/create-polyfill-size-estimation.js)
• Change coupling: default-config.js ↔ experimental-config.js (core/config/default-config.js)
• Change coupling: default-config.js ↔ generate-insight-audits.js (core/config/default-config.js)
• Change coupling: filters.js ↔ base-artifacts.js (core/config/filters.js)
• Change coupling: layout-shifts.js ↔ trace-elements.js (core/audits/layout-shifts.js)
• Change coupling: main.js ↔ util.js (treemap/app/src/main.js)
• Change coupling: sidebar.tsx ↔ util.ts (flow-report/src/sidebar/sidebar.tsx)
• Change coupling: util.ts ↔ report.tsx (flow-report/src/util.ts)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (core/scripts/legacy-javascript/yarn.lock)
• Critical CVE: [GHSA redacted] (core/scripts/legacy-javascript/yarn.lock)
• Critical CVE: [GHSA redacted] (yarn.lock)
• Critical CVE: [GHSA redacted] (core/scripts/legacy-javascript/yarn.lock)
• …and 152 more

• Audit.generateAuditResult (cognitive 17) (core/audits/audit.js)
• AutocompleteAudit.audit (cognitive 20) (core/audits/autocomplete.js)
• Baseline.audit (cognitive 29) (core/audits/baseline.js)
• Baseline.audit (cyclomatic 20) (core/audits/baseline.js)
• Canonical.collectCanonicalURLs (cognitive 25) (core/audits/seo/canonical.js)
• CategoryRenderer.renderAudit (cognitive 18) (report/renderer/category-renderer.js)
• CategoryRenderer.renderAudit (cyclomatic 16) (report/renderer/category-renderer.js)
• ClassTooLong: TreemapViewer (treemap/app/src/main.js)
• Coverage not measured — JavaScript/TypeScript suite
• CpuProfileModel.collectProfileEvents (cognitive 21) (core/lib/tracehouse/cpu-profile-model.js)
• CpuProfileModel.collectProfileEvents (cyclomatic 16) (core/lib/tracehouse/cpu-profile-model.js)
• DetailsRenderer._getEntityGroupItems (cognitive 20) (report/renderer/details-renderer.js)
• DetailsRenderer._getEntityGroupItems (cyclomatic 18) (report/renderer/details-renderer.js)
• DetailsRenderer._renderTable (cognitive 36) (report/renderer/details-renderer.js)
• DetailsRenderer._renderTable (cyclomatic 16) (report/renderer/details-renderer.js)
• DetailsRenderer._renderTableValue (cyclomatic 21) (report/renderer/details-renderer.js)
• Documentation: no contributor guidance (docs/readme.md)
• Documentation: no usage examples (docs/readme.md)
• FileTooLong: src/main.js (treemap/app/src/main.js)
• FunctionTooLong: cli-flags.getYargsParser (cli/cli-flags.js)
• …and 210 more

• 33 commits — 29 feature/other, 4 fixes

• cli/test — 8 commits
• core/test — 5 commits
• (root) — 3 commits
• .github/workflows — 2 commits
• core/audits — 2 commits
• core/config — 2 commits
• core/gather — 2 commits
• core/scripts — 2 commits
• report/renderer — 2 commits
• shared/localization — 2 commits
• build/build-bundle.js — 1 commit
• third-party/ard — 1 commit
• third-party/devtools-tests — 1 commit

• fix: core(gather): fix broken cycle detection in recurse functions (#17173)
• fix: tests(devtools): fix build and e2e test integration (#17233)
• fix: tests(devtools): fix device mode readiness check for latest devtools-frontend (#17164)
• fix: tests: fix dbw expectation to exclude period (#17246)
• change: clients(lightrider): export bundle w/ cjs compat (#17161)
• change: core(config): group llms.txt and ARD audits under agent discovery (#17210)
• change: core(deprecations): handle new column offset (#17234)
• change: core(fetcher): add response header capture support (#17167)
• change: core(user-flow): support aborting pending navigations (#17067)
• change: core(webmcp-form-coverage): pass instead of n/a when all forms covered (#17242)
• change: core(webmcp-registered-tools): warn when exceeding recommended limit (#17221)
• change: core: add plugin version to LHR credits (#17232)
• change: core: centralize and enforce plugin category validation (#17243)
• change: deps: upgrade deps (#17206)
• change: deps: upgrade deps (#17245)
• change: i18n: import (#17241)
• change: misc(build): add precompiled standalone schema validator (#17195)
• change: misc(build): extract bundled dependency licenses into generated LICENSE (#17172)
• change: misc(ci): add weekly ARD conformance script sync check (#17171)
• change: misc(ci): pin action hashes and restrict permissions in cron-weekly (#17201)
• …and 13 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

GoogleChrome/lighthouse was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.