chrome-ai-bridge 1.0.0

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

@@ -0,0 +1,209 @@
+// 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

@@ -0,0 +1,340 @@
+// 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;
+}