@mcp-b/chrome-devtools-mcp 1.0.2 → 1.0.3-beta.0

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

@@ -1,209 +0,0 @@
-// Copyright 2025 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 { linearInterpolation } from './Statistics.js';
-import { InsightCategory, } from './types.js';
-export const UIStrings = {
-    /**
-     * @description Title of an insight that provides information and suggestions of resources that could improve their caching.
-     */
-    title: 'Use efficient cache lifetimes',
-    /**
-     * @description Text to tell the user about how caching can help improve performance.
-     */
-    description: 'A long cache lifetime can speed up repeat visits to your page. [Learn more about caching](https://developer.chrome.com/docs/performance/insights/cache).',
-    /**
-     * @description Column for a font loaded by the page to render text.
-     */
-    requestColumn: 'Request',
-    /**
-     * @description Column for a resource cache's Time To Live.
-     */
-    cacheTTL: 'Cache TTL',
-    /**
-     * @description Text describing that there were no requests found that need caching.
-     */
-    noRequestsToCache: 'No requests with inefficient cache policies',
-    /**
-     * @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',
-};
-const str_ = i18n.i18n.registerUIStrings('models/trace/insights/Cache.ts', UIStrings);
-export const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-// Threshold for cache hits.
-const IGNORE_THRESHOLD_IN_PERCENT = 0.925;
-function finalize(partialModel) {
-    return {
-        insightKey: "Cache" /* InsightKeys.CACHE */,
-        strings: UIStrings,
-        title: i18nString(UIStrings.title),
-        description: i18nString(UIStrings.description),
-        docs: 'https://developer.chrome.com/docs/performance/insights/cache',
-        category: InsightCategory.ALL,
-        state: partialModel.requests.length > 0 ? 'fail' : 'pass',
-        ...partialModel,
-    };
-}
-/**
- * Determines if a request is "cacheable".
- * A request is "cacheable" if it is of the appropriate protocol and resource type
- * (see Helpers.Network.NON_NETWORK_SCHEMES and Helpers.Network.STATIC_RESOURCE_TYPE)
- * and has the appropriate statusCodes.
- */
-export function isCacheable(request) {
-    // Caching doesn't make sense for requests not loaded over the network.
-    if (Helpers.Network.NON_NETWORK_SCHEMES.includes(request.args.data.protocol)) {
-        return false;
-    }
-    return Boolean(Helpers.Network.CACHEABLE_STATUS_CODES.has(request.args.data.statusCode) &&
-        Helpers.Network.STATIC_RESOURCE_TYPES.has(request.args.data.resourceType || "Other" /* Protocol.Network.ResourceType.Other */));
-}
-/**
- * Returns max-age if defined, otherwise expires header if defined, and null if not.
- */
-export function computeCacheLifetimeInSeconds(headers, cacheControl) {
-    if (cacheControl?.['max-age'] !== undefined) {
-        return cacheControl['max-age'];
-    }
-    const expiresHeaders = headers.find(h => h.name === 'expires')?.value ?? null;
-    if (expiresHeaders) {
-        const expires = new Date(expiresHeaders).getTime();
-        // Treat expires values as having already expired.
-        if (!expires) {
-            return 0;
-        }
-        return Math.ceil((expires - Date.now()) / 1000);
-    }
-    return null;
-}
-/**
- * Computes the percent likelihood that a return visit will be within the cache lifetime, based on
- * historical Chrome UMA stats (see RESOURCE_AGE_IN_HOURS_DECILES comment).
- *
- * This function returns values on this curve: https://www.desmos.com/calculator/eaqiszhugy (but using seconds, rather than hours)
- * See http://github.com/GoogleChrome/lighthouse/pull/3531 for history.
- */
-function getCacheHitProbability(maxAgeInSeconds) {
-    // This array contains the hand wavy distribution of the age of a resource in hours at the time of
-    // cache hit at 0th, 10th, 20th, 30th, etc percentiles. This is used to compute `wastedMs` since there
-    // are clearly diminishing returns to cache duration i.e. 6 months is not 2x better than 3 months.
-    // Based on UMA stats for HttpCache.StaleEntry.Validated.Age. see https://www.desmos.com/calculator/jjwc5mzuwd
-    // This UMA data is from 2017 but the metric isn't tracked any longer in 2025.
-    const RESOURCE_AGE_IN_HOURS_DECILES = [0, 0.2, 1, 3, 8, 12, 24, 48, 72, 168, 8760, Infinity];
-    const maxAgeInHours = maxAgeInSeconds / 3600;
-    const upperDecileIndex = RESOURCE_AGE_IN_HOURS_DECILES.findIndex(decile => decile >= maxAgeInHours);
-    // Clip the likelihood between 0 and 1
-    if (upperDecileIndex === RESOURCE_AGE_IN_HOURS_DECILES.length - 1) {
-        return 1;
-    }
-    if (upperDecileIndex === 0) {
-        return 0;
-    }
-    // Use the two closest decile points as control points
-    const upperDecileValue = RESOURCE_AGE_IN_HOURS_DECILES[upperDecileIndex];
-    const lowerDecileValue = RESOURCE_AGE_IN_HOURS_DECILES[upperDecileIndex - 1];
-    const upperDecile = upperDecileIndex / 10;
-    const lowerDecile = (upperDecileIndex - 1) / 10;
-    // Approximate the real likelihood with linear interpolation
-    return linearInterpolation(lowerDecileValue, lowerDecile, upperDecileValue, upperDecile, maxAgeInHours);
-}
-export function getCombinedHeaders(responseHeaders) {
-    const headers = new Map();
-    for (const header of responseHeaders) {
-        const name = header.name.toLowerCase();
-        if (headers.get(name)) {
-            headers.set(name, `${headers.get(name)}, ${header.value}`);
-        }
-        else {
-            headers.set(name, header.value);
-        }
-    }
-    return headers;
-}
-/**
- * Returns whether a request contains headers that disable caching.
- * Disabled caching is checked on the 'cache-control' and 'pragma' headers.
- */
-export function cachingDisabled(headers, parsedCacheControl) {
-    const cacheControl = headers?.get('cache-control') ?? null;
-    const pragma = headers?.get('pragma') ?? null;
-    // The HTTP/1.0 Pragma header can disable caching if cache-control is not set, see https://tools.ietf.org/html/rfc7234#section-5.4
-    if (!cacheControl && pragma?.includes('no-cache')) {
-        return true;
-    }
-    // If we have any of these, the user intentionally doesn't want to cache.
-    if (parsedCacheControl &&
-        (parsedCacheControl['must-revalidate'] || parsedCacheControl['no-cache'] || parsedCacheControl['no-store'] ||
-            parsedCacheControl['private'])) {
-        return true;
-    }
-    return false;
-}
-export function isCacheInsight(model) {
-    return model.insightKey === "Cache" /* InsightKeys.CACHE */;
-}
-export function generateInsight(data, context) {
-    const isWithinContext = (event) => Helpers.Timing.eventIsInBounds(event, context.bounds);
-    const contextRequests = data.NetworkRequests.byTime.filter(isWithinContext);
-    const results = [];
-    let totalWastedBytes = 0;
-    const wastedBytesByRequestId = new Map();
-    for (const req of contextRequests) {
-        if (!req.args.data.responseHeaders || !isCacheable(req)) {
-            continue;
-        }
-        const headers = getCombinedHeaders(req.args.data.responseHeaders);
-        const cacheControl = headers.get('cache-control') ?? null;
-        const parsedDirectives = Helpers.Network.parseCacheControl(cacheControl);
-        // Skip requests that are deliberately avoiding caching.
-        if (cachingDisabled(headers, parsedDirectives)) {
-            continue;
-        }
-        let ttl = computeCacheLifetimeInSeconds(req.args.data.responseHeaders, parsedDirectives);
-        // Ignore if a non-positive number.
-        if (ttl !== null && (!Number.isFinite(ttl) || ttl <= 0)) {
-            continue;
-        }
-        ttl = ttl || 0;
-        // Ignore >= 30d.
-        const ttlDays = ttl / 86400;
-        if (ttlDays >= 30) {
-            continue;
-        }
-        // If cache lifetime is high enough, let's skip.
-        const cacheHitProbability = getCacheHitProbability(ttl);
-        if (cacheHitProbability > IGNORE_THRESHOLD_IN_PERCENT) {
-            continue;
-        }
-        const transferSize = req.args.data.encodedDataLength || 0;
-        const wastedBytes = (1 - cacheHitProbability) * transferSize;
-        wastedBytesByRequestId.set(req.args.data.requestId, wastedBytes);
-        totalWastedBytes += wastedBytes;
-        results.push({ request: req, ttl, wastedBytes });
-    }
-    // Sort by transfer size.
-    results.sort((a, b) => {
-        return b.request.args.data.decodedBodyLength - a.request.args.data.decodedBodyLength || a.ttl - b.ttl;
-    });
-    return finalize({
-        relatedEvents: results.map(r => r.request),
-        requests: results,
-        metricSavings: metricSavingsForWastedBytes(wastedBytesByRequestId, context),
-        wastedBytes: totalWastedBytes,
-    });
-}
-export function createOverlayForRequest(request) {
-    return {
-        type: 'ENTRY_OUTLINE',
-        entry: request,
-        outlineReason: 'ERROR',
-    };
-}
-export function createOverlays(model) {
-    return model.requests.map(req => createOverlayForRequest(req.request));
-}

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

@@ -1,340 +0,0 @@
-// 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 Helpers from '../helpers/helpers.js';
-import * as Types from '../types/types.js';
-import { getLogNormalScore } from './Statistics.js';
-const GRAPH_SAVINGS_PRECISION = 50;
-export function getInsight(insightName, insightSet) {
-    const insight = insightSet.model[insightName];
-    if (insight instanceof Error) {
-        return null;
-    }
-    // For some reason typescript won't narrow the type by removing Error, so do it manually.
-    return insight;
-}
-export function getLCP(insightSet) {
-    const insight = getInsight("LCPBreakdown" /* InsightKeys.LCP_BREAKDOWN */, insightSet);
-    if (!insight || !insight.lcpMs || !insight.lcpEvent) {
-        return null;
-    }
-    const value = Helpers.Timing.milliToMicro(insight.lcpMs);
-    return { value, event: insight.lcpEvent };
-}
-export function getINP(insightSet) {
-    const insight = getInsight("INPBreakdown" /* InsightKeys.INP_BREAKDOWN */, insightSet);
-    if (!insight?.longestInteractionEvent?.dur) {
-        return null;
-    }
-    const value = insight.longestInteractionEvent.dur;
-    return { value, event: insight.longestInteractionEvent };
-}
-export function getCLS(insightSet) {
-    const insight = getInsight("CLSCulprits" /* InsightKeys.CLS_CULPRITS */, insightSet);
-    if (!insight) {
-        // Unlike the other metrics, there is always a value for CLS even with no data.
-        return { value: 0, worstClusterEvent: null };
-    }
-    // TODO(cjamcl): the CLS insight should be doing this for us.
-    let maxScore = 0;
-    let worstCluster;
-    for (const cluster of insight.clusters) {
-        if (cluster.clusterCumulativeScore > maxScore) {
-            maxScore = cluster.clusterCumulativeScore;
-            worstCluster = cluster;
-        }
-    }
-    return { value: maxScore, worstClusterEvent: worstCluster ?? null };
-}
-export function evaluateLCPMetricScore(value) {
-    return getLogNormalScore({ p10: 2500, median: 4000 }, value);
-}
-export function evaluateINPMetricScore(value) {
-    return getLogNormalScore({ p10: 200, median: 500 }, value);
-}
-export function evaluateCLSMetricScore(value) {
-    return getLogNormalScore({ p10: 0.1, median: 0.25 }, value);
-}
-function getPageResult(cruxFieldData, url, origin, scope = null) {
-    return cruxFieldData.find(result => {
-        const key = scope ? result[`${scope.pageScope}-${scope.deviceScope}`]?.record.key :
-            (result['url-ALL'] || result['origin-ALL'])?.record.key;
-        return (key?.url && key.url === url) || (key?.origin && key.origin === origin);
-    });
-}
-function getMetricResult(pageResult, name, scope = null) {
-    const scopes = [];
-    if (scope) {
-        scopes.push(scope);
-    }
-    else {
-        scopes.push({ pageScope: 'url', deviceScope: 'ALL' });
-        scopes.push({ pageScope: 'origin', deviceScope: 'ALL' });
-    }
-    for (const scope of scopes) {
-        const key = `${scope.pageScope}-${scope.deviceScope}`;
-        let value = pageResult[key]?.record.metrics[name]?.percentiles?.p75;
-        if (typeof value === 'string') {
-            value = Number(value);
-        }
-        if (typeof value === 'number' && Number.isFinite(value)) {
-            return { value, pageScope: scope.pageScope };
-        }
-    }
-    return null;
-}
-function getMetricTimingResult(pageResult, name, scope = null) {
-    const result = getMetricResult(pageResult, name, scope);
-    if (result) {
-        const valueMs = result.value;
-        return { value: Helpers.Timing.milliToMicro(valueMs), pageScope: result.pageScope };
-    }
-    return null;
-}
-export function getFieldMetricsForInsightSet(insightSet, metadata, scope = null) {
-    const cruxFieldData = metadata?.cruxFieldData;
-    if (!cruxFieldData) {
-        return null;
-    }
-    const pageResult = getPageResult(cruxFieldData, insightSet.url.href, insightSet.url.origin, scope);
-    if (!pageResult) {
-        return null;
-    }
-    return {
-        fcp: getMetricTimingResult(pageResult, 'first_contentful_paint', scope),
-        lcp: getMetricTimingResult(pageResult, 'largest_contentful_paint', scope),
-        inp: getMetricTimingResult(pageResult, 'interaction_to_next_paint', scope),
-        cls: getMetricResult(pageResult, 'cumulative_layout_shift', scope),
-        lcpBreakdown: {
-            ttfb: getMetricTimingResult(pageResult, 'largest_contentful_paint_image_time_to_first_byte', scope),
-            loadDelay: getMetricTimingResult(pageResult, 'largest_contentful_paint_image_resource_load_delay', scope),
-            loadDuration: getMetricTimingResult(pageResult, 'largest_contentful_paint_image_resource_load_duration', scope),
-            renderDelay: getMetricTimingResult(pageResult, 'largest_contentful_paint_image_element_render_delay', scope),
-        }
-    };
-}
-export function calculateMetricWeightsForSorting(insightSet, metadata) {
-    const weights = {
-        lcp: 1 / 3,
-        inp: 1 / 3,
-        cls: 1 / 3,
-    };
-    const cruxFieldData = metadata?.cruxFieldData;
-    if (!cruxFieldData) {
-        return weights;
-    }
-    const fieldMetrics = getFieldMetricsForInsightSet(insightSet, metadata);
-    if (!fieldMetrics) {
-        return weights;
-    }
-    const fieldLcp = fieldMetrics.lcp?.value ?? null;
-    const fieldInp = fieldMetrics.inp?.value ?? null;
-    const fieldCls = fieldMetrics.cls?.value ?? null;
-    const fieldLcpScore = fieldLcp !== null ? evaluateLCPMetricScore(Helpers.Timing.microToMilli(fieldLcp)) : 0;
-    const fieldInpScore = fieldInp !== null ? evaluateINPMetricScore(Helpers.Timing.microToMilli(fieldInp)) : 0;
-    const fieldClsScore = fieldCls !== null ? evaluateCLSMetricScore(fieldCls) : 0;
-    const fieldLcpScoreInverted = 1 - fieldLcpScore;
-    const fieldInpScoreInverted = 1 - fieldInpScore;
-    const fieldClsScoreInverted = 1 - fieldClsScore;
-    const invertedSum = fieldLcpScoreInverted + fieldInpScoreInverted + fieldClsScoreInverted;
-    if (!invertedSum) {
-        return weights;
-    }
-    weights.lcp = fieldLcpScoreInverted / invertedSum;
-    weights.inp = fieldInpScoreInverted / invertedSum;
-    weights.cls = fieldClsScoreInverted / invertedSum;
-    return weights;
-}
-/**
- * Simulates the provided graph before and after the byte savings from `wastedBytesByRequestId` are applied.
- */
-function estimateSavingsWithGraphs(wastedBytesByRequestId, simulator, graph) {
-    const simulationBeforeChanges = simulator.simulate(graph);
-    const originalTransferSizes = new Map();
-    graph.traverse(node => {
-        if (node.type !== 'network') {
-            return;
-        }
-        const wastedBytes = wastedBytesByRequestId.get(node.request.requestId);
-        if (!wastedBytes) {
-            return;
-        }
-        const original = node.request.transferSize;
-        originalTransferSizes.set(node.request.requestId, original);
-        node.request.transferSize = Math.max(original - wastedBytes, 0);
-    });
-    const simulationAfterChanges = simulator.simulate(graph);
-    // Restore the original transfer size after we've done our simulation
-    graph.traverse(node => {
-        if (node.type !== 'network') {
-            return;
-        }
-        const originalTransferSize = originalTransferSizes.get(node.request.requestId);
-        if (originalTransferSize === undefined) {
-            return;
-        }
-        node.request.transferSize = originalTransferSize;
-    });
-    let savings = simulationBeforeChanges.timeInMs - simulationAfterChanges.timeInMs;
-    savings = Math.round(savings / GRAPH_SAVINGS_PRECISION) * GRAPH_SAVINGS_PRECISION;
-    return Types.Timing.Milli(savings);
-}
-/**
- * Estimates the FCP & LCP savings for wasted bytes in `wastedBytesByRequestId`.
- */
-export function metricSavingsForWastedBytes(wastedBytesByRequestId, context) {
-    if (!context.navigation || !context.lantern) {
-        return;
-    }
-    if (!wastedBytesByRequestId.size) {
-        return { FCP: Types.Timing.Milli(0), LCP: Types.Timing.Milli(0) };
-    }
-    const simulator = context.lantern.simulator;
-    const fcpGraph = context.lantern.metrics.firstContentfulPaint.optimisticGraph;
-    const lcpGraph = context.lantern.metrics.largestContentfulPaint.optimisticGraph;
-    return {
-        FCP: estimateSavingsWithGraphs(wastedBytesByRequestId, simulator, fcpGraph),
-        LCP: estimateSavingsWithGraphs(wastedBytesByRequestId, simulator, lcpGraph),
-    };
-}
-/**
- * Returns whether the network request was sent encoded.
- */
-export function isRequestCompressed(request) {
-    if (!request.args.data.responseHeaders) {
-        return false;
-    }
-    // FYI: In Lighthouse, older devtools logs (like our test fixtures) seems to be
-    // lower case, while modern logs are Cased-Like-This.
-    const patterns = [
-        /^content-encoding$/i, /^x-content-encoding-over-network$/i,
-        /^x-original-content-encoding$/i, // Lightrider.
-    ];
-    const compressionTypes = ['gzip', 'br', 'deflate', 'zstd'];
-    return request.args.data.responseHeaders.some(header => patterns.some(p => header.name.match(p)) && compressionTypes.includes(header.value));
-}
-export function isRequestServedFromBrowserCache(request) {
-    if (!request.args.data.responseHeaders || request.args.data.failed) {
-        return false;
-    }
-    // Not Modified?
-    if (request.args.data.statusCode === 304) {
-        return true;
-    }
-    // TODO: for some reason ResourceReceiveResponse events never show a 304 status
-    // code, so the above is never gonna work. For now, fall back to a dirty check of
-    // looking at the ratio of transfer size and resource size. If it's really small,
-    // we certainly did not use the network to fetch it.
-    const { transferSize, resourceSize } = getRequestSizes(request);
-    const ratio = resourceSize ? transferSize / resourceSize : 0;
-    if (ratio < 0.01) {
-        return true;
-    }
-    return false;
-}
-function getRequestSizes(request) {
-    const resourceSize = request.args.data.decodedBodyLength;
-    const transferSize = request.args.data.encodedDataLength;
-    return { resourceSize, transferSize };
-}
-/**
- * Estimates the number of bytes the content of this network record would have consumed on the network based on the
- * uncompressed size (totalBytes). Uses the actual transfer size from the network record if applicable,
- * minus the size of the response headers.
- *
- * @param totalBytes Uncompressed size of the resource
- */
-export function estimateCompressedContentSize(request, totalBytes, resourceType) {
-    if (!request || isRequestServedFromBrowserCache(request)) {
-        // We don't know how many bytes this asset used on the network, but we can guess it was
-        // roughly the size of the content gzipped.
-        // See https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/optimize-encoding-and-transfer for specific CSS/Script examples
-        // See https://discuss.httparchive.org/t/file-size-and-compression-savings/145 for fallback multipliers
-        switch (resourceType) {
-            case 'Stylesheet':
-                // Stylesheets tend to compress extremely well.
-                return Math.round(totalBytes * 0.2);
-            case 'Script':
-            case 'Document':
-                // Scripts and HTML compress fairly well too.
-                return Math.round(totalBytes * 0.33);
-            default:
-                // Otherwise we'll just fallback to the average savings in HTTPArchive
-                return Math.round(totalBytes * 0.5);
-        }
-    }
-    // Get the size of the response body on the network.
-    const { transferSize, resourceSize } = getRequestSizes(request);
-    let contentTransferSize = transferSize;
-    if (!isRequestCompressed(request)) {
-        // This is not compressed, so we can use resourceSize directly.
-        // This would be equivalent to transfer size minus headers transfer size, but transfer size
-        // may also include bytes for SSL connection etc.
-        contentTransferSize = resourceSize;
-    }
-    // TODO(cjamcl): Get "responseHeadersTransferSize" in Network handler.
-    // else if (request.responseHeadersTransferSize) {
-    //   // Subtract the size of the encoded headers.
-    //   contentTransferSize =
-    //     Math.max(0, contentTransferSize - request.responseHeadersTransferSize);
-    // }
-    if (request.args.data.resourceType === resourceType) {
-        // This was a regular standalone asset, just use the transfer size.
-        return contentTransferSize;
-    }
-    // This was an asset that was inlined in a different resource type (e.g. HTML document).
-    // Use the compression ratio of the resource to estimate the total transferred bytes.
-    // Get the compression ratio, if it's an invalid number, assume no compression.
-    const compressionRatio = Number.isFinite(resourceSize) && resourceSize > 0 ? (contentTransferSize / resourceSize) : 1;
-    return Math.round(totalBytes * compressionRatio);
-}
-/**
- * Utility function to estimate the ratio of the compression of a script.
- * This excludes the size of the response headers.
- */
-export function estimateCompressionRatioForScript(script) {
-    if (!script.request) {
-        // Can't find request, so just use 1.
-        return 1;
-    }
-    const request = script.request;
-    const contentLength = request.args.data.decodedBodyLength ?? script.content?.length ?? 0;
-    const compressedSize = estimateCompressedContentSize(request, contentLength, "Script" /* Protocol.Network.ResourceType.Script */);
-    if (contentLength === 0 || compressedSize === 0) {
-        return 1;
-    }
-    const compressionRatio = compressedSize / contentLength;
-    return compressionRatio;
-}
-export function calculateDocFirstByteTs(docRequest) {
-    if (docRequest.args.data.protocol === 'file') {
-        // file: requests do not have timings
-        return docRequest.ts;
-    }
-    const timing = docRequest.args.data.timing;
-    if (!timing) {
-        // Older traces do not have timings.
-        return null;
-    }
-    // Time that first byte (headers) are received.
-    // For older traces, receiveHeadersStart can be missing (ex: web.dev.json.gz).
-    // In that case use the headers end timing, which should be pretty close to when
-    // the headers start.
-    return Types.Timing.Micro(Helpers.Timing.secondsToMicro(timing.requestTime) +
-        Helpers.Timing.milliToMicro(timing.receiveHeadersStart ?? timing.receiveHeadersEnd));
-}
-/**
- * Calculates the trace bounds for the given insight that are relevant.
- *
- * Uses the insight's overlays to determine the relevant trace bounds. If there are
- * no overlays, falls back to the insight set's navigation bounds.
- */
-export function insightBounds(insight, insightSetBounds) {
-    const overlays = insight.createOverlays?.() ?? [];
-    const windows = overlays.map(Helpers.Timing.traceWindowFromOverlay).filter(bounds => !!bounds);
-    const overlaysBounds = Helpers.Timing.combineTraceWindowsMicro(windows);
-    if (overlaysBounds) {
-        return overlaysBounds;
-    }
-    return insightSetBounds;
-}