chrome-ai-bridge 1.0.0

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/insights/ForcedReflow.js

@@ -0,0 +1,161 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as Platform from '../../../core/platform/platform.js';
+import * as Extras from '../extras/extras.js';
+import * as Helpers from '../helpers/helpers.js';
+import * as Types from '../types/types.js';
+import { InsightCategory, } from './types.js';
+export const UIStrings = {
+    /**
+     * @description Title of an insight that provides details about Forced reflow.
+     */
+    title: 'Forced reflow',
+    /**
+     * @description Text to describe the forced reflow.
+     */
+    description: 'A forced reflow occurs when JavaScript queries geometric properties (such as `offsetWidth`) after styles have been invalidated by a change to the DOM state. This can result in poor performance. Learn more about [forced reflows](https://developer.chrome.com/docs/performance/insights/forced-reflow) and possible mitigations.',
+    /**
+     * @description Title of a list to provide related stack trace data
+     */
+    reflowCallFrames: 'Call frames that trigger reflow',
+    /**
+     * @description Text to describe the top time-consuming function call
+     */
+    topTimeConsumingFunctionCall: 'Top function call',
+    /**
+     * @description Text to describe the total reflow time
+     */
+    totalReflowTime: 'Total reflow time',
+    /**
+     * @description Text to describe CPU processor tasks that could not be attributed to any specific source code.
+     */
+    unattributed: '[unattributed]',
+    /**
+     * @description Text for the name of anonymous functions
+     */
+    anonymous: '(anonymous)',
+};
+const str_ = i18n.i18n.registerUIStrings('models/trace/insights/ForcedReflow.ts', UIStrings);
+export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+function getCallFrameId(callFrame) {
+    return callFrame.scriptId + ':' + callFrame.lineNumber + ':' + callFrame.columnNumber;
+}
+function getLargestTopLevelFunctionData(forcedReflowEvents, traceParsedData) {
+    const entryToNodeMap = traceParsedData.Renderer.entryToNode;
+    const dataByTopLevelFunction = new Map();
+    if (forcedReflowEvents.length === 0) {
+        return;
+    }
+    for (const event of forcedReflowEvents) {
+        // Gather the stack traces by searching in the tree
+        const traceNode = entryToNodeMap.get(event);
+        if (!traceNode) {
+            continue;
+        }
+        let node = traceNode.parent;
+        let topLevelFunctionCall;
+        let topLevelFunctionCallEvent;
+        while (node) {
+            const eventData = node.entry;
+            if (Types.Events.isProfileCall(eventData)) {
+                topLevelFunctionCall = eventData.callFrame;
+                topLevelFunctionCallEvent = eventData;
+            }
+            else {
+                // We have finished searching bottom up data
+                if (Types.Events.isFunctionCall(eventData) && eventData.args.data &&
+                    Types.Events.objectIsCallFrame(eventData.args.data)) {
+                    topLevelFunctionCall = eventData.args.data;
+                    topLevelFunctionCallEvent = eventData;
+                }
+                break;
+            }
+            node = node.parent;
+        }
+        if (!topLevelFunctionCall || !topLevelFunctionCallEvent) {
+            continue;
+        }
+        const aggregatedDataId = getCallFrameId(topLevelFunctionCall);
+        const aggregatedData = Platform.MapUtilities.getWithDefault(dataByTopLevelFunction, aggregatedDataId, () => ({
+            topLevelFunctionCall,
+            totalReflowTime: 0,
+            topLevelFunctionCallEvents: [],
+        }));
+        aggregatedData.totalReflowTime += (event.dur ?? 0);
+        aggregatedData.topLevelFunctionCallEvents.push(topLevelFunctionCallEvent);
+    }
+    let topTimeConsumingData = undefined;
+    dataByTopLevelFunction.forEach(data => {
+        if (!topTimeConsumingData || data.totalReflowTime > topTimeConsumingData.totalReflowTime) {
+            topTimeConsumingData = data;
+        }
+    });
+    return topTimeConsumingData;
+}
+function finalize(partialModel) {
+    return {
+        insightKey: "ForcedReflow" /* InsightKeys.FORCED_REFLOW */,
+        strings: UIStrings,
+        title: i18nString(UIStrings.title),
+        description: i18nString(UIStrings.description),
+        docs: 'https://developer.chrome.com/docs/performance/insights/forced-reflow',
+        category: InsightCategory.ALL,
+        state: partialModel.aggregatedBottomUpData.length !== 0 ? 'fail' : 'pass',
+        ...partialModel,
+    };
+}
+function getBottomCallFrameForEvent(event, traceParsedData) {
+    const profileStackTrace = Extras.StackTraceForEvent.get(event, traceParsedData);
+    const eventTopCallFrame = Helpers.Trace.getStackTraceTopCallFrameInEventPayload(event);
+    return profileStackTrace?.callFrames[0] ?? eventTopCallFrame ?? null;
+}
+export function isForcedReflowInsight(model) {
+    return model.insightKey === "ForcedReflow" /* InsightKeys.FORCED_REFLOW */;
+}
+export function generateInsight(traceParsedData, context) {
+    const isWithinContext = (event) => {
+        const frameId = Helpers.Trace.frameIDForEvent(event);
+        if (frameId !== context.frameId) {
+            return false;
+        }
+        return Helpers.Timing.eventIsInBounds(event, context.bounds);
+    };
+    const bottomUpDataMap = new Map();
+    const events = traceParsedData.Warnings.perWarning.get('FORCED_REFLOW')?.filter(isWithinContext) ?? [];
+    for (const event of events) {
+        const bottomCallFrame = getBottomCallFrameForEvent(event, traceParsedData);
+        const bottomCallId = bottomCallFrame ? getCallFrameId(bottomCallFrame) : 'UNATTRIBUTED';
+        const bottomUpData = Platform.MapUtilities.getWithDefault(bottomUpDataMap, bottomCallId, () => ({
+            bottomUpData: bottomCallFrame,
+            totalTime: 0,
+            relatedEvents: [],
+        }));
+        bottomUpData.totalTime += event.dur ?? 0;
+        bottomUpData.relatedEvents.push(event);
+    }
+    const topLevelFunctionCallData = getLargestTopLevelFunctionData(events, traceParsedData);
+    return finalize({
+        relatedEvents: events,
+        topLevelFunctionCallData,
+        aggregatedBottomUpData: [...bottomUpDataMap.values()],
+    });
+}
+export function createOverlays(model) {
+    if (!model.topLevelFunctionCallData) {
+        return [];
+    }
+    const allBottomUpEvents = [...model.aggregatedBottomUpData.values().flatMap(data => data.relatedEvents)];
+    return [
+        ...createOverlayForEvents(model.topLevelFunctionCallData.topLevelFunctionCallEvents, 'INFO'),
+        ...createOverlayForEvents(allBottomUpEvents),
+    ];
+}
+export function createOverlayForEvents(events, outlineReason = 'ERROR') {
+    return events.map(e => ({
+        type: 'ENTRY_OUTLINE',
+        entry: e,
+        outlineReason,
+    }));
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/insights/INPBreakdown.js

@@ -0,0 +1,129 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as Handlers from '../handlers/handlers.js';
+import * as Helpers from '../helpers/helpers.js';
+import { InsightCategory, } from './types.js';
+export const UIStrings = {
+    /**
+     * @description Text to tell the user about the longest user interaction.
+     */
+    description: 'Start investigating [how to improve INP](https://developer.chrome.com/docs/performance/insights/inp-breakdown) by looking at the longest subpart.',
+    /**
+     * @description Title for the performance insight "INP breakdown", which shows a breakdown of INP by subparts / sections.
+     */
+    title: 'INP breakdown',
+    /**
+     * @description Label used for the subpart/component/stage/section of a larger duration.
+     */
+    subpart: 'Subpart',
+    /**
+     * @description Label used for a time duration.
+     */
+    duration: 'Duration',
+    // TODO: these are repeated in InteractionBreakdown. Add a place for common strings?
+    /**
+     * @description Text shown next to the interaction event's input delay time in the detail view.
+     */
+    inputDelay: 'Input delay',
+    /**
+     * @description Text shown next to the interaction event's thread processing duration in the detail view.
+     */
+    processingDuration: 'Processing duration',
+    /**
+     * @description Text shown next to the interaction event's presentation delay time in the detail view.
+     */
+    presentationDelay: 'Presentation delay',
+    /**
+     * @description Text status indicating that no user interactions were detected.
+     */
+    noInteractions: 'No interactions detected',
+};
+const str_ = i18n.i18n.registerUIStrings('models/trace/insights/INPBreakdown.ts', UIStrings);
+export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export function isINPBreakdownInsight(insight) {
+    return insight.insightKey === "INPBreakdown" /* InsightKeys.INP_BREAKDOWN */;
+}
+function finalize(partialModel) {
+    let state = 'pass';
+    if (partialModel.longestInteractionEvent) {
+        const classification = Handlers.ModelHandlers.UserInteractions.scoreClassificationForInteractionToNextPaint(partialModel.longestInteractionEvent.dur);
+        if (classification === "good" /* Handlers.ModelHandlers.PageLoadMetrics.ScoreClassification.GOOD */) {
+            state = 'informative';
+        }
+        else {
+            state = 'fail';
+        }
+    }
+    return {
+        insightKey: "INPBreakdown" /* InsightKeys.INP_BREAKDOWN */,
+        strings: UIStrings,
+        title: i18nString(UIStrings.title),
+        description: i18nString(UIStrings.description),
+        docs: 'https://developer.chrome.com/docs/performance/insights/inp-breakdown',
+        category: InsightCategory.INP,
+        state,
+        ...partialModel,
+    };
+}
+export function generateInsight(data, context) {
+    const interactionEvents = data.UserInteractions.interactionEventsWithNoNesting.filter(event => {
+        return Helpers.Timing.eventIsInBounds(event, context.bounds);
+    });
+    if (!interactionEvents.length) {
+        // A valid result, when there is no user interaction.
+        return finalize({});
+    }
+    const longestByInteractionId = new Map();
+    for (const event of interactionEvents) {
+        const key = event.interactionId;
+        const longest = longestByInteractionId.get(key);
+        if (!longest || event.dur > longest.dur) {
+            longestByInteractionId.set(key, event);
+        }
+    }
+    const normalizedInteractionEvents = [...longestByInteractionId.values()];
+    normalizedInteractionEvents.sort((a, b) => b.dur - a.dur);
+    // INP is the "nearest-rank"/inverted_cdf 98th percentile, except Chrome only
+    // keeps the 10 worst events around, so it can never be more than the 10th from
+    // last array element. To keep things simpler, sort desc and pick from front.
+    // See https://source.chromium.org/chromium/chromium/src/+/main:components/page_load_metrics/browser/responsiveness_metrics_normalization.cc;l=45-59;drc=cb0f9c8b559d9c7c3cb4ca94fc1118cc015d38ad
+    const highPercentileIndex = Math.min(9, Math.floor(normalizedInteractionEvents.length / 50));
+    return finalize({
+        relatedEvents: [normalizedInteractionEvents[0]],
+        longestInteractionEvent: normalizedInteractionEvents[0],
+        highPercentileInteractionEvent: normalizedInteractionEvents[highPercentileIndex],
+    });
+}
+/**
+ * If `subpart` is -1, then all subparts are included. Otherwise it's just that index.
+ **/
+export function createOverlaysForSubpart(event, subpartIndex = -1) {
+    const p1 = Helpers.Timing.traceWindowFromMicroSeconds(event.ts, (event.ts + event.inputDelay));
+    const p2 = Helpers.Timing.traceWindowFromMicroSeconds(p1.max, (p1.max + event.mainThreadHandling));
+    const p3 = Helpers.Timing.traceWindowFromMicroSeconds(p2.max, (p2.max + event.presentationDelay));
+    let sections = [
+        { bounds: p1, label: i18nString(UIStrings.inputDelay), showDuration: true },
+        { bounds: p2, label: i18nString(UIStrings.processingDuration), showDuration: true },
+        { bounds: p3, label: i18nString(UIStrings.presentationDelay), showDuration: true },
+    ];
+    if (subpartIndex !== -1) {
+        sections = [sections[subpartIndex]];
+    }
+    return [
+        {
+            type: 'TIMESPAN_BREAKDOWN',
+            sections,
+            renderLocation: 'BELOW_EVENT',
+            entry: event,
+        },
+    ];
+}
+export function createOverlays(model) {
+    const event = model.longestInteractionEvent;
+    if (!event) {
+        return [];
+    }
+    return createOverlaysForSubpart(event);
+}

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/insights/ImageDelivery.js

@@ -0,0 +1,263 @@
+// Copyright 2024 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as Helpers from '../helpers/helpers.js';
+import { metricSavingsForWastedBytes } from './Common.js';
+import { InsightCategory, } from './types.js';
+export const UIStrings = {
+    /**
+     * @description Title of an insight that recommends ways to reduce the size of images downloaded and used on the page.
+     */
+    title: 'Improve image delivery',
+    /**
+     * @description Description of an insight that recommends ways to reduce the size of images downloaded and used on the page.
+     */
+    description: 'Reducing the download time of images can improve the perceived load time of the page and LCP. [Learn more about optimizing image size](https://developer.chrome.com/docs/performance/insights/image-delivery)',
+    /**
+     * @description Message displayed in a chip explaining that an image file size is large for the # of pixels it has and recommends possible adjustments to improve the image size.
+     */
+    useCompression: 'Increasing the image compression factor could improve this image\'s download size.',
+    /**
+     * @description Message displayed in a chip explaining that an image file size is large for the # of pixels it has and recommends possible adjustments to improve the image size.
+     */
+    useModernFormat: 'Using a modern image format (WebP, AVIF) or increasing the image compression could improve this image\'s download size.',
+    /**
+     * @description Message displayed in a chip advising the user to use video formats instead of GIFs because videos generally have smaller file sizes.
+     */
+    useVideoFormat: 'Using video formats instead of GIFs can improve the download size of animated content.',
+    /**
+     * @description Message displayed in a chip explaining that an image was displayed on the page with dimensions much smaller than the image file dimensions.
+     * @example {1000x500} PH1
+     * @example {100x50} PH2
+     */
+    useResponsiveSize: 'This image file is larger than it needs to be ({PH1}) for its displayed dimensions ({PH2}). Use responsive images to reduce the image download size.',
+    /**
+     * @description Column header for a table column containing network requests for images which can improve their file size (e.g. use a different format, increase compression, etc).
+     */
+    optimizeFile: 'Optimize file size',
+    /**
+     * @description Table row value representing the remaining items not shown in the table due to size constraints. This row will always represent at least 2 items.
+     * @example {5} PH1
+     */
+    others: '{PH1} others',
+    /**
+     * @description Text status indicating that no potential optimizations were found for any image file
+     */
+    noOptimizableImages: 'No optimizable images',
+    /**
+     * @description Text describing the estimated number of bytes that an image file optimization can save. This text is appended to another block of text describing the image optimization in more detail. "Est" means "Estimated".
+     * @example {Use the correct image dimensions to reduce the image file size.} PH1
+     * @example {50 MB} PH2
+     */
+    estimatedSavings: '{PH1} (Est {PH2})',
+};
+const str_ = i18n.i18n.registerUIStrings('models/trace/insights/ImageDelivery.ts', UIStrings);
+export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+/**
+ * Even JPEGs with lots of detail can usually be compressed down to <1 byte per pixel
+ * Using 4:2:2 subsampling already gets an uncompressed bitmap to 2 bytes per pixel.
+ * The compression ratio for JPEG is usually somewhere around 10:1 depending on content, so
+ * 8:1 is a reasonable expectation for web content which is 1.5MB for a 6MP image.
+ *
+ * WebP usually gives ~20% additional savings on top of that, so we will assume 10:1 for WebP.
+ * This is quite pessimistic as their study shows a photographic compression ratio of ~29:1.
+ * https://developers.google.com/speed/webp/docs/webp_lossless_alpha_study#results
+ *
+ * AVIF usually gives ~20% additional savings on top of WebP, so we will use 12:1 for AVIF.
+ * This is quite pessimistic as Netflix study shows a photographic compression ratio of ~40:1
+ * (0.4 *bits* per pixel at SSIM 0.97).
+ * https://netflixtechblog.com/avif-for-next-generation-image-coding-b1d75675fe4
+ */
+const TARGET_BYTES_PER_PIXEL_AVIF = 2 * 1 / 12;
+/**
+ * If GIFs are above this size, we'll flag them
+ * See https://github.com/GoogleChrome/lighthouse/pull/4885#discussion_r178406623 and https://github.com/GoogleChrome/lighthouse/issues/4696#issuecomment-370979920
+ */
+const GIF_SIZE_THRESHOLD = 100 * 1024;
+const BYTE_SAVINGS_THRESHOLD = 4096;
+// Ignore up to 12KB of waste for responsive images if an effort was made with breakpoints.
+const BYTE_SAVINGS_THRESHOLD_RESPONSIVE_BREAKPOINTS = 12288;
+export var ImageOptimizationType;
+(function (ImageOptimizationType) {
+    ImageOptimizationType["ADJUST_COMPRESSION"] = "ADJUST_COMPRESSION";
+    ImageOptimizationType["MODERN_FORMAT_OR_COMPRESSION"] = "MODERN_FORMAT_OR_COMPRESSION";
+    ImageOptimizationType["VIDEO_FORMAT"] = "VIDEO_FORMAT";
+    ImageOptimizationType["RESPONSIVE_SIZE"] = "RESPONSIVE_SIZE";
+})(ImageOptimizationType || (ImageOptimizationType = {}));
+export function isImageDeliveryInsight(model) {
+    return model.insightKey === 'ImageDelivery';
+}
+export function getOptimizationMessage(optimization) {
+    switch (optimization.type) {
+        case ImageOptimizationType.ADJUST_COMPRESSION:
+            return i18nString(UIStrings.useCompression);
+        case ImageOptimizationType.MODERN_FORMAT_OR_COMPRESSION:
+            return i18nString(UIStrings.useModernFormat);
+        case ImageOptimizationType.VIDEO_FORMAT:
+            return i18nString(UIStrings.useVideoFormat);
+        case ImageOptimizationType.RESPONSIVE_SIZE:
+            return i18nString(UIStrings.useResponsiveSize, {
+                PH1: `${optimization.fileDimensions.width}x${optimization.fileDimensions.height}`,
+                PH2: `${optimization.displayDimensions.width}x${optimization.displayDimensions.height}`,
+            });
+    }
+}
+export function getOptimizationMessageWithBytes(optimization) {
+    const byteSavingsText = i18n.ByteUtilities.bytesToString(optimization.byteSavings);
+    const optimizationMessage = getOptimizationMessage(optimization);
+    return i18nString(UIStrings.estimatedSavings, { PH1: optimizationMessage, PH2: byteSavingsText });
+}
+function finalize(partialModel) {
+    return {
+        insightKey: "ImageDelivery" /* InsightKeys.IMAGE_DELIVERY */,
+        strings: UIStrings,
+        title: i18nString(UIStrings.title),
+        description: i18nString(UIStrings.description),
+        docs: 'https://developer.chrome.com/docs/performance/insights/image-delivery',
+        category: InsightCategory.LCP,
+        state: partialModel.optimizableImages.length > 0 ? 'fail' : 'pass',
+        ...partialModel,
+        relatedEvents: new Map(partialModel.optimizableImages.map(image => [image.request, image.optimizations.map(getOptimizationMessageWithBytes)])),
+    };
+}
+/**
+ * Calculate rough savings percentage based on 1000 real gifs transcoded to video
+ * https://github.com/GoogleChrome/lighthouse/issues/4696#issuecomment-380296510
+ */
+function estimateGIFPercentSavings(request) {
+    return Math.round((29.1 * Math.log10(request.args.data.decodedBodyLength) - 100.7)) / 100;
+}
+function getDisplayedSize(data, paintImage) {
+    // Note: for traces made prior to metadata.hostDPR (which means no data in
+    // paintEventToCorrectedDisplaySize), the displayed size unexpectedly ignores any
+    // emulated DPR and so the results may be very misleading.
+    return data.ImagePainting.paintEventToCorrectedDisplaySize.get(paintImage) ?? {
+        width: paintImage.args.data.width,
+        height: paintImage.args.data.height,
+    };
+}
+function getPixelCounts(data, paintImage) {
+    const { width, height } = getDisplayedSize(data, paintImage);
+    return {
+        filePixels: paintImage.args.data.srcWidth * paintImage.args.data.srcHeight,
+        displayedPixels: width * height,
+    };
+}
+export function generateInsight(data, context) {
+    const isWithinContext = (event) => Helpers.Timing.eventIsInBounds(event, context.bounds);
+    const contextRequests = data.NetworkRequests.byTime.filter(isWithinContext);
+    const optimizableImages = [];
+    for (const request of contextRequests) {
+        if (request.args.data.resourceType !== 'Image') {
+            continue;
+        }
+        if (request.args.data.mimeType === 'image/svg+xml') {
+            continue;
+        }
+        // If the request was redirected, the image paints will have the pre-redirect URL.
+        const url = request.args.data.redirects[0]?.url ?? request.args.data.url;
+        const imagePaints = data.ImagePainting.paintImageEventForUrl.get(url)?.filter(isWithinContext);
+        // This will filter out things like preloaded image requests where an image file is downloaded
+        // but never rendered on the page.
+        if (!imagePaints?.length) {
+            continue;
+        }
+        const largestImagePaint = imagePaints.reduce((prev, curr) => {
+            const prevPixels = getPixelCounts(data, prev).displayedPixels;
+            const currPixels = getPixelCounts(data, curr).displayedPixels;
+            return prevPixels > currPixels ? prev : curr;
+        });
+        const { filePixels: imageFilePixels, displayedPixels: largestImageDisplayPixels, } = getPixelCounts(data, largestImagePaint);
+        // Decoded body length is almost always the right one to be using because of the below:
+        //     `encodedDataLength = decodedBodyLength + headers`.
+        // HOWEVER, there are some cases where an image is compressed again over the network and transfer size
+        // is smaller (see https://github.com/GoogleChrome/lighthouse/pull/4968).
+        // Use the min of the two numbers to be safe.
+        const imageBytes = Math.min(request.args.data.decodedBodyLength, request.args.data.encodedDataLength);
+        const bytesPerPixel = imageBytes / imageFilePixels;
+        let optimizations = [];
+        if (request.args.data.mimeType === 'image/gif') {
+            if (imageBytes > GIF_SIZE_THRESHOLD) {
+                const percentSavings = estimateGIFPercentSavings(request);
+                const byteSavings = Math.round(imageBytes * percentSavings);
+                optimizations.push({ type: ImageOptimizationType.VIDEO_FORMAT, byteSavings });
+            }
+        }
+        else if (bytesPerPixel > TARGET_BYTES_PER_PIXEL_AVIF) {
+            const idealAvifImageSize = Math.round(TARGET_BYTES_PER_PIXEL_AVIF * imageFilePixels);
+            const byteSavings = imageBytes - idealAvifImageSize;
+            if (request.args.data.mimeType !== 'image/webp' && request.args.data.mimeType !== 'image/avif') {
+                optimizations.push({ type: ImageOptimizationType.MODERN_FORMAT_OR_COMPRESSION, byteSavings });
+            }
+            else {
+                optimizations.push({ type: ImageOptimizationType.ADJUST_COMPRESSION, byteSavings });
+            }
+        }
+        // At this point (before looking at image size), the # of optimizations should only ever be 1 or 0
+        // Math.max handles both cases correctly, and is defensive against future patches that would add
+        // more than 1 format-specific optimization by this point.
+        const imageByteSavingsFromFormat = Math.max(0, ...optimizations.map(o => o.byteSavings));
+        let imageByteSavings = imageByteSavingsFromFormat;
+        const wastedPixelRatio = 1 - (largestImageDisplayPixels / imageFilePixels);
+        // Ignore CSS images because it's difficult to determine what is a spritesheet,
+        // and the reward-to-effort ratio for responsive CSS images is quite low https://css-tricks.com/responsive-images-css/.
+        if (wastedPixelRatio > 0 && !largestImagePaint.args.data.isCSS) {
+            const byteSavings = Math.round(wastedPixelRatio * imageBytes);
+            const hadBreakpoints = largestImagePaint.args.data.isPicture || largestImagePaint.args.data.srcsetAttribute;
+            if (!hadBreakpoints || byteSavings > BYTE_SAVINGS_THRESHOLD_RESPONSIVE_BREAKPOINTS) {
+                // This will compound the byte savings from any potential format changes with the image size
+                // optimization added here.
+                imageByteSavings += Math.round(wastedPixelRatio * (imageBytes - imageByteSavingsFromFormat));
+                const { width, height } = getDisplayedSize(data, largestImagePaint);
+                optimizations.push({
+                    type: ImageOptimizationType.RESPONSIVE_SIZE,
+                    byteSavings,
+                    fileDimensions: {
+                        width: Math.round(largestImagePaint.args.data.srcWidth),
+                        height: Math.round(largestImagePaint.args.data.srcHeight),
+                    },
+                    displayDimensions: {
+                        width: Math.round(width),
+                        height: Math.round(height),
+                    },
+                });
+            }
+        }
+        optimizations = optimizations.filter(optimization => optimization.byteSavings > BYTE_SAVINGS_THRESHOLD);
+        if (optimizations.length > 0) {
+            optimizableImages.push({
+                request,
+                largestImagePaint,
+                optimizations,
+                byteSavings: imageByteSavings,
+            });
+        }
+    }
+    const wastedBytesByRequestId = new Map();
+    for (const image of optimizableImages) {
+        wastedBytesByRequestId.set(image.request.args.data.requestId, image.byteSavings);
+    }
+    // Sort by savings, then by size of image.
+    optimizableImages.sort((a, b) => {
+        if (b.byteSavings !== a.byteSavings) {
+            return b.byteSavings - a.byteSavings;
+        }
+        return b.request.args.data.decodedBodyLength - a.request.args.data.decodedBodyLength;
+    });
+    return finalize({
+        optimizableImages,
+        metricSavings: metricSavingsForWastedBytes(wastedBytesByRequestId, context),
+        wastedBytes: optimizableImages.reduce((total, img) => total + img.byteSavings, 0),
+    });
+}
+export function createOverlayForRequest(request) {
+    return {
+        type: 'ENTRY_OUTLINE',
+        entry: request,
+        outlineReason: 'ERROR',
+    };
+}
+export function createOverlays(model) {
+    return model.optimizableImages.map(image => createOverlayForRequest(image.request));
+}