@mcp-b/chrome-devtools-mcp 1.1.0 → 1.1.1

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/simulation/Simulator.js

@@ -0,0 +1,450 @@
+// 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 Core from '../core/core.js';
+import * as Graph from '../graph/graph.js';
+import { ConnectionPool } from './ConnectionPool.js';
+import { Constants } from './Constants.js';
+import { DNSCache } from './DNSCache.js';
+import { SimulatorTimingMap } from './SimulationTimingMap.js';
+import { TCPConnection } from './TCPConnection.js';
+const defaultThrottling = Constants.throttling.mobileSlow4G;
+// see https://cs.chromium.org/search/?q=kDefaultMaxNumDelayableRequestsPerClient&sq=package:chromium&type=cs
+const DEFAULT_MAXIMUM_CONCURRENT_REQUESTS = 10;
+// layout tasks tend to be less CPU-bound and do not experience the same increase in duration
+const DEFAULT_LAYOUT_TASK_MULTIPLIER = 0.5;
+// if a task takes more than 10 seconds it's usually a sign it isn't actually CPU bound and we're overestimating
+const DEFAULT_MAXIMUM_CPU_TASK_DURATION = 10000;
+const NodeState = {
+    NotReadyToStart: 0,
+    ReadyToStart: 1,
+    InProgress: 2,
+    Complete: 3,
+};
+const PriorityStartTimePenalty = {
+    VeryHigh: 0,
+    High: 0.25,
+    Medium: 0.5,
+    Low: 1,
+    VeryLow: 2,
+};
+const ALL_SIMULATION_NODE_TIMINGS = new Map();
+class Simulator {
+    static createSimulator(settings) {
+        const { throttlingMethod, throttling, precomputedLanternData, networkAnalysis } = settings;
+        const options = {
+            additionalRttByOrigin: networkAnalysis.additionalRttByOrigin,
+            serverResponseTimeByOrigin: networkAnalysis.serverResponseTimeByOrigin,
+            observedThroughput: networkAnalysis.throughput,
+        };
+        // If we have precomputed lantern data, overwrite our observed estimates and use precomputed instead
+        // for increased stability.
+        if (precomputedLanternData) {
+            options.additionalRttByOrigin = new Map(Object.entries(precomputedLanternData.additionalRttByOrigin));
+            options.serverResponseTimeByOrigin = new Map(Object.entries(precomputedLanternData.serverResponseTimeByOrigin));
+        }
+        switch (throttlingMethod) {
+            case 'provided':
+                options.rtt = networkAnalysis.rtt;
+                options.throughput = networkAnalysis.throughput;
+                options.cpuSlowdownMultiplier = 1;
+                options.layoutTaskMultiplier = 1;
+                break;
+            case 'devtools':
+                if (throttling) {
+                    options.rtt = throttling.requestLatencyMs / Constants.throttling.DEVTOOLS_RTT_ADJUSTMENT_FACTOR;
+                    options.throughput =
+                        throttling.downloadThroughputKbps * 1024 / Constants.throttling.DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR;
+                }
+                options.cpuSlowdownMultiplier = 1;
+                options.layoutTaskMultiplier = 1;
+                break;
+            case 'simulate':
+                if (throttling) {
+                    options.rtt = throttling.rttMs;
+                    options.throughput = throttling.throughputKbps * 1024;
+                    options.cpuSlowdownMultiplier = throttling.cpuSlowdownMultiplier;
+                }
+                break;
+            default:
+                // intentionally fallback to simulator defaults
+                break;
+        }
+        return new Simulator(options);
+    }
+    options;
+    _rtt;
+    throughput;
+    maximumConcurrentRequests;
+    cpuSlowdownMultiplier;
+    layoutTaskMultiplier;
+    cachedNodeListByStartPosition;
+    nodeTimings;
+    numberInProgressByType;
+    nodes;
+    dns;
+    connectionPool;
+    constructor(options) {
+        this.options = Object.assign({
+            rtt: defaultThrottling.rttMs,
+            throughput: defaultThrottling.throughputKbps * 1024,
+            maximumConcurrentRequests: DEFAULT_MAXIMUM_CONCURRENT_REQUESTS,
+            cpuSlowdownMultiplier: defaultThrottling.cpuSlowdownMultiplier,
+            layoutTaskMultiplier: DEFAULT_LAYOUT_TASK_MULTIPLIER,
+            additionalRttByOrigin: new Map(),
+            serverResponseTimeByOrigin: new Map(),
+        }, options);
+        this._rtt = this.options.rtt;
+        this.throughput = this.options.throughput;
+        this.maximumConcurrentRequests = Math.max(Math.min(TCPConnection.maximumSaturatedConnections(this._rtt, this.throughput), this.options.maximumConcurrentRequests), 1);
+        this.cpuSlowdownMultiplier = this.options.cpuSlowdownMultiplier;
+        this.layoutTaskMultiplier = this.cpuSlowdownMultiplier * this.options.layoutTaskMultiplier;
+        this.cachedNodeListByStartPosition = [];
+        // Properties reset on every `.simulate` call but duplicated here for type checking
+        this.nodeTimings = new SimulatorTimingMap();
+        this.numberInProgressByType = new Map();
+        this.nodes = {};
+        this.dns = new DNSCache({ rtt: this._rtt });
+        // @ts-expect-error
+        this.connectionPool = null;
+        if (!Number.isFinite(this._rtt)) {
+            throw new Core.LanternError(`Invalid rtt ${this._rtt}`);
+        }
+        if (!Number.isFinite(this.throughput)) {
+            throw new Core.LanternError(`Invalid throughput ${this.throughput}`);
+        }
+    }
+    get rtt() {
+        return this._rtt;
+    }
+    initializeConnectionPool(graph) {
+        const records = [];
+        graph.getRootNode().traverse(node => {
+            if (node.type === Graph.BaseNode.types.NETWORK) {
+                records.push(node.request);
+            }
+        });
+        this.connectionPool = new ConnectionPool(records, this.options);
+    }
+    /**
+     * Initializes the various state data structures such _nodeTimings and the _node Sets by state.
+     */
+    initializeAuxiliaryData() {
+        this.nodeTimings = new SimulatorTimingMap();
+        this.numberInProgressByType = new Map();
+        this.nodes = {};
+        this.cachedNodeListByStartPosition = [];
+        // NOTE: We don't actually need *all* of these sets, but the clarity that each node progresses
+        // through the system is quite nice.
+        for (const state of Object.values(NodeState)) {
+            this.nodes[state] = new Set();
+        }
+    }
+    numberInProgress(type) {
+        return this.numberInProgressByType.get(type) || 0;
+    }
+    markNodeAsReadyToStart(node, queuedTime) {
+        const nodeStartPosition = Simulator.computeNodeStartPosition(node);
+        const firstNodeIndexWithGreaterStartPosition = this.cachedNodeListByStartPosition.findIndex(candidate => Simulator.computeNodeStartPosition(candidate) > nodeStartPosition);
+        const insertionIndex = firstNodeIndexWithGreaterStartPosition === -1 ? this.cachedNodeListByStartPosition.length :
+            firstNodeIndexWithGreaterStartPosition;
+        this.cachedNodeListByStartPosition.splice(insertionIndex, 0, node);
+        this.nodes[NodeState.ReadyToStart].add(node);
+        this.nodes[NodeState.NotReadyToStart].delete(node);
+        this.nodeTimings.setReadyToStart(node, { queuedTime });
+    }
+    markNodeAsInProgress(node, startTime) {
+        const indexOfNodeToStart = this.cachedNodeListByStartPosition.indexOf(node);
+        this.cachedNodeListByStartPosition.splice(indexOfNodeToStart, 1);
+        this.nodes[NodeState.InProgress].add(node);
+        this.nodes[NodeState.ReadyToStart].delete(node);
+        this.numberInProgressByType.set(node.type, this.numberInProgress(node.type) + 1);
+        this.nodeTimings.setInProgress(node, { startTime });
+    }
+    markNodeAsComplete(node, endTime, connectionTiming) {
+        this.nodes[NodeState.Complete].add(node);
+        this.nodes[NodeState.InProgress].delete(node);
+        this.numberInProgressByType.set(node.type, this.numberInProgress(node.type) - 1);
+        this.nodeTimings.setCompleted(node, { endTime, connectionTiming });
+        // Try to add all its dependents to the queue
+        for (const dependent of node.getDependents()) {
+            // Skip dependent node if one of its dependencies hasn't finished yet
+            const dependencies = dependent.getDependencies();
+            if (dependencies.some(dep => !this.nodes[NodeState.Complete].has(dep))) {
+                continue;
+            }
+            // Otherwise add it to the queue
+            this.markNodeAsReadyToStart(dependent, endTime);
+        }
+    }
+    acquireConnection(request) {
+        return this.connectionPool.acquire(request);
+    }
+    getNodesSortedByStartPosition() {
+        // Make a copy so we don't skip nodes due to concurrent modification
+        return Array.from(this.cachedNodeListByStartPosition);
+    }
+    startNodeIfPossible(node, totalElapsedTime) {
+        if (node.type === Graph.BaseNode.types.CPU) {
+            // Start a CPU task if there's no other CPU task in process
+            if (this.numberInProgress(node.type) === 0) {
+                this.markNodeAsInProgress(node, totalElapsedTime);
+            }
+            return;
+        }
+        if (node.type !== Graph.BaseNode.types.NETWORK) {
+            throw new Core.LanternError('Unsupported');
+        }
+        // If a network request is connectionless, we can always start it, so skip the connection checks
+        if (!node.isConnectionless) {
+            // Start a network request if we're not at max requests and a connection is available
+            const numberOfActiveRequests = this.numberInProgress(node.type);
+            if (numberOfActiveRequests >= this.maximumConcurrentRequests) {
+                return;
+            }
+            const connection = this.acquireConnection(node.request);
+            if (!connection) {
+                return;
+            }
+        }
+        this.markNodeAsInProgress(node, totalElapsedTime);
+    }
+    /**
+     * Updates each connection in use with the available throughput based on the number of network requests
+     * currently in flight.
+     */
+    updateNetworkCapacity() {
+        const inFlight = this.numberInProgress(Graph.BaseNode.types.NETWORK);
+        if (inFlight === 0) {
+            return;
+        }
+        for (const connection of this.connectionPool.connectionsInUse()) {
+            connection.setThroughput(this.throughput / inFlight);
+        }
+    }
+    /**
+     * Estimates the number of milliseconds remaining given current conditions before the node is complete.
+     */
+    estimateTimeRemaining(node) {
+        if (node.type === Graph.BaseNode.types.CPU) {
+            return this.estimateCPUTimeRemaining(node);
+        }
+        if (node.type === Graph.BaseNode.types.NETWORK) {
+            return this.estimateNetworkTimeRemaining(node);
+        }
+        throw new Core.LanternError('Unsupported');
+    }
+    estimateCPUTimeRemaining(cpuNode) {
+        const timingData = this.nodeTimings.getCpuStarted(cpuNode);
+        const multiplier = cpuNode.didPerformLayout() ? this.layoutTaskMultiplier : this.cpuSlowdownMultiplier;
+        const totalDuration = Math.min(Math.round(cpuNode.duration / 1000 * multiplier), DEFAULT_MAXIMUM_CPU_TASK_DURATION);
+        const estimatedTimeElapsed = totalDuration - timingData.timeElapsed;
+        this.nodeTimings.setCpuEstimated(cpuNode, { estimatedTimeElapsed });
+        return estimatedTimeElapsed;
+    }
+    estimateNetworkTimeRemaining(networkNode) {
+        const request = networkNode.request;
+        const timingData = this.nodeTimings.getNetworkStarted(networkNode);
+        let timeElapsed = 0;
+        if (networkNode.fromDiskCache) {
+            // Rough access time for seeking to location on disk and reading sequentially.
+            // 8ms per seek + 20ms/MB
+            // @see http://norvig.com/21-days.html#answers
+            const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
+            timeElapsed = 8 + 20 * sizeInMb - timingData.timeElapsed;
+        }
+        else if (networkNode.isNonNetworkProtocol) {
+            // Estimates for the overhead of a data URL in Chromium and the decoding time for base64-encoded data.
+            // 2ms per request + 10ms/MB
+            // @see traces on https://dopiaza.org/tools/datauri/examples/index.php
+            const sizeInMb = (request.resourceSize || 0) / 1024 / 1024;
+            timeElapsed = 2 + 10 * sizeInMb - timingData.timeElapsed;
+        }
+        else {
+            const connection = this.connectionPool.acquireActiveConnectionFromRequest(request);
+            const dnsResolutionTime = this.dns.getTimeUntilResolution(request, {
+                requestedAt: timingData.startTime,
+                shouldUpdateCache: true,
+            });
+            const timeAlreadyElapsed = timingData.timeElapsed;
+            const calculation = connection.simulateDownloadUntil(request.transferSize - timingData.bytesDownloaded, { timeAlreadyElapsed, dnsResolutionTime, maximumTimeToElapse: Infinity });
+            timeElapsed = calculation.timeElapsed;
+        }
+        const estimatedTimeElapsed = timeElapsed + timingData.timeElapsedOvershoot;
+        this.nodeTimings.setNetworkEstimated(networkNode, { estimatedTimeElapsed });
+        return estimatedTimeElapsed;
+    }
+    /**
+     * Computes and returns the minimum estimated completion time of the nodes currently in progress.
+     */
+    findNextNodeCompletionTime() {
+        let minimumTime = Infinity;
+        for (const node of this.nodes[NodeState.InProgress]) {
+            minimumTime = Math.min(minimumTime, this.estimateTimeRemaining(node));
+        }
+        return minimumTime;
+    }
+    /**
+     * Given a time period, computes the progress toward completion that the node made during that time.
+     */
+    updateProgressMadeInTimePeriod(node, timePeriodLength, totalElapsedTime) {
+        const timingData = this.nodeTimings.getInProgress(node);
+        const isFinished = timingData.estimatedTimeElapsed === timePeriodLength;
+        if (node.type === Graph.BaseNode.types.CPU || node.isConnectionless) {
+            if (isFinished) {
+                this.markNodeAsComplete(node, totalElapsedTime);
+            }
+            else {
+                timingData.timeElapsed += timePeriodLength;
+            }
+            return;
+        }
+        if (node.type !== Graph.BaseNode.types.NETWORK) {
+            throw new Core.LanternError('Unsupported');
+        }
+        if (!('bytesDownloaded' in timingData)) {
+            throw new Core.LanternError('Invalid timing data');
+        }
+        const request = node.request;
+        const connection = this.connectionPool.acquireActiveConnectionFromRequest(request);
+        const dnsResolutionTime = this.dns.getTimeUntilResolution(request, {
+            requestedAt: timingData.startTime,
+            shouldUpdateCache: true,
+        });
+        const calculation = connection.simulateDownloadUntil(request.transferSize - timingData.bytesDownloaded, {
+            dnsResolutionTime,
+            timeAlreadyElapsed: timingData.timeElapsed,
+            maximumTimeToElapse: timePeriodLength - timingData.timeElapsedOvershoot,
+        });
+        connection.setCongestionWindow(calculation.congestionWindow);
+        connection.setH2OverflowBytesDownloaded(calculation.extraBytesDownloaded);
+        if (isFinished) {
+            connection.setWarmed(true);
+            this.connectionPool.release(request);
+            this.markNodeAsComplete(node, totalElapsedTime, calculation.connectionTiming);
+        }
+        else {
+            timingData.timeElapsed += calculation.timeElapsed;
+            timingData.timeElapsedOvershoot += calculation.timeElapsed - timePeriodLength;
+            timingData.bytesDownloaded += calculation.bytesDownloaded;
+        }
+    }
+    computeFinalNodeTimings() {
+        const completeNodeTimingEntries = this.nodeTimings.getNodes().map(node => {
+            return [node, this.nodeTimings.getCompleted(node)];
+        });
+        // Most consumers will want the entries sorted by startTime, so insert them in that order
+        completeNodeTimingEntries.sort((a, b) => a[1].startTime - b[1].startTime);
+        // Trimmed version of type `Lantern.Simulation.NodeTiming`.
+        const nodeTimingEntries = completeNodeTimingEntries.map(([node, timing]) => {
+            return [
+                node,
+                {
+                    startTime: timing.startTime,
+                    endTime: timing.endTime,
+                    duration: timing.endTime - timing.startTime,
+                },
+            ];
+        });
+        return {
+            nodeTimings: new Map(nodeTimingEntries),
+            completeNodeTimings: new Map(completeNodeTimingEntries),
+        };
+    }
+    getOptions() {
+        return this.options;
+    }
+    /**
+     * Estimates the time taken to process all of the graph's nodes, returns the overall time along with
+     * each node annotated by start/end times.
+     *
+     * Simulator/connection pool are allowed to deviate from what was
+     * observed in the trace/devtoolsLog and start requests as soon as they are queued (i.e. do not
+     * wait around for a warm connection to be available if the original request was fetched on a warm
+     * connection).
+     */
+    simulate(graph, options) {
+        if (Graph.BaseNode.findCycle(graph)) {
+            throw new Core.LanternError('Cannot simulate graph with cycle');
+        }
+        options = Object.assign({
+            label: undefined,
+        }, options);
+        // initialize the necessary data containers
+        this.dns = new DNSCache({ rtt: this._rtt });
+        this.initializeConnectionPool(graph);
+        this.initializeAuxiliaryData();
+        const nodesNotReadyToStart = this.nodes[NodeState.NotReadyToStart];
+        const nodesReadyToStart = this.nodes[NodeState.ReadyToStart];
+        const nodesInProgress = this.nodes[NodeState.InProgress];
+        const rootNode = graph.getRootNode();
+        rootNode.traverse(node => nodesNotReadyToStart.add(node));
+        let totalElapsedTime = 0;
+        let iteration = 0;
+        // root node is always ready to start
+        this.markNodeAsReadyToStart(rootNode, totalElapsedTime);
+        // loop as long as we have nodes in the queue or currently in progress
+        while (nodesReadyToStart.size || nodesInProgress.size) {
+            // move all possible queued nodes to in progress
+            for (const node of this.getNodesSortedByStartPosition()) {
+                this.startNodeIfPossible(node, totalElapsedTime);
+            }
+            if (!nodesInProgress.size) {
+                // Interplay between fromDiskCache and connectionReused can be incorrect,
+                // have to give up.
+                throw new Core.LanternError('Failed to start a node');
+            }
+            // set the available throughput for all connections based on # in-flight
+            this.updateNetworkCapacity();
+            // find the time that the next node will finish
+            const minimumTime = this.findNextNodeCompletionTime();
+            totalElapsedTime += minimumTime;
+            // While this is no longer strictly necessary, it's always better than hanging
+            if (!Number.isFinite(minimumTime) || iteration > 100000) {
+                throw new Core.LanternError('Simulation failed, depth exceeded');
+            }
+            iteration++;
+            // update how far each node will progress until that point
+            for (const node of nodesInProgress) {
+                this.updateProgressMadeInTimePeriod(node, minimumTime, totalElapsedTime);
+            }
+        }
+        // `nodeTimings` are used for simulator consumers, `completeNodeTimings` kept for debugging.
+        const { nodeTimings, completeNodeTimings } = this.computeFinalNodeTimings();
+        ALL_SIMULATION_NODE_TIMINGS.set(options.label || 'unlabeled', completeNodeTimings);
+        return {
+            timeInMs: totalElapsedTime,
+            nodeTimings,
+        };
+    }
+    computeWastedMsFromWastedBytes(wastedBytes) {
+        const { throughput, observedThroughput } = this.options;
+        // https://github.com/GoogleChrome/lighthouse/pull/13323#issuecomment-962031709
+        // 0 throughput means the no (additional) throttling is expected.
+        // This is common for desktop + devtools throttling where throttling is additive and we don't want any additional.
+        const bitsPerSecond = throughput === 0 ? observedThroughput : throughput;
+        if (bitsPerSecond === 0) {
+            return 0;
+        }
+        const wastedBits = wastedBytes * 8;
+        const wastedMs = wastedBits / bitsPerSecond * 1000;
+        // This is an estimate of wasted time, so we won't be more precise than 10ms.
+        return Math.round(wastedMs / 10) * 10;
+    }
+    // Used by Lighthouse asset-saver
+    static get allNodeTimings() {
+        return ALL_SIMULATION_NODE_TIMINGS;
+    }
+    /**
+     * We attempt to start nodes by their observed start time using the request priority as a tie breaker.
+     * When simulating, just because a low priority image started 5ms before a high priority image doesn't mean
+     * it would have happened like that when the network was slower.
+     */
+    static computeNodeStartPosition(node) {
+        if (node.type === 'cpu') {
+            return node.startTime;
+        }
+        return node.startTime + (PriorityStartTimePenalty[node.request.priority] * 1000 * 1000 || 0);
+    }
+}
+export { Simulator };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/simulation/TCPConnection.js

@@ -0,0 +1,154 @@
+// 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.
+const INITIAL_CONGESTION_WINDOW = 10;
+const TCP_SEGMENT_SIZE = 1460;
+class TCPConnection {
+    warmed;
+    ssl;
+    h2;
+    rtt;
+    throughput;
+    serverLatency;
+    _congestionWindow;
+    h2OverflowBytesDownloaded;
+    constructor(rtt, throughput, serverLatency = 0, ssl = true, h2 = false) {
+        this.warmed = false;
+        this.ssl = ssl;
+        this.h2 = h2;
+        this.rtt = rtt;
+        this.throughput = throughput;
+        this.serverLatency = serverLatency;
+        this._congestionWindow = INITIAL_CONGESTION_WINDOW;
+        this.h2OverflowBytesDownloaded = 0;
+    }
+    static maximumSaturatedConnections(rtt, availableThroughput) {
+        const roundTripsPerSecond = 1000 / rtt;
+        const bytesPerRoundTrip = TCP_SEGMENT_SIZE;
+        const bytesPerSecond = roundTripsPerSecond * bytesPerRoundTrip;
+        const minimumThroughputRequiredPerRequest = bytesPerSecond * 8;
+        return Math.floor(availableThroughput / minimumThroughputRequiredPerRequest);
+    }
+    computeMaximumCongestionWindowInSegments() {
+        const bytesPerSecond = this.throughput / 8;
+        const secondsPerRoundTrip = this.rtt / 1000;
+        const bytesPerRoundTrip = bytesPerSecond * secondsPerRoundTrip;
+        return Math.floor(bytesPerRoundTrip / TCP_SEGMENT_SIZE);
+    }
+    setThroughput(throughput) {
+        this.throughput = throughput;
+    }
+    setCongestionWindow(congestion) {
+        this._congestionWindow = congestion;
+    }
+    setWarmed(warmed) {
+        this.warmed = warmed;
+    }
+    isH2() {
+        return this.h2;
+    }
+    get congestionWindow() {
+        return this._congestionWindow;
+    }
+    /**
+     * Sets the number of excess bytes that are available to this connection on future downloads, only
+     * applies to H2 connections.
+     */
+    setH2OverflowBytesDownloaded(bytes) {
+        if (!this.h2) {
+            return;
+        }
+        this.h2OverflowBytesDownloaded = bytes;
+    }
+    clone() {
+        return Object.assign(new TCPConnection(this.rtt, this.throughput), this);
+    }
+    /**
+     * Simulates a network download of a particular number of bytes over an optional maximum amount of time
+     * and returns information about the ending state.
+     *
+     * See https://hpbn.co/building-blocks-of-tcp/#three-way-handshake and
+     *  https://hpbn.co/transport-layer-security-tls/#tls-handshake for details.
+     */
+    simulateDownloadUntil(bytesToDownload, options) {
+        const { timeAlreadyElapsed = 0, maximumTimeToElapse = Infinity, dnsResolutionTime = 0 } = options || {};
+        if (this.warmed && this.h2) {
+            bytesToDownload -= this.h2OverflowBytesDownloaded;
+        }
+        const twoWayLatency = this.rtt;
+        const oneWayLatency = twoWayLatency / 2;
+        const maximumCongestionWindow = this.computeMaximumCongestionWindowInSegments();
+        let handshakeAndRequest = oneWayLatency;
+        if (!this.warmed) {
+            handshakeAndRequest =
+                // DNS lookup
+                dnsResolutionTime +
+                    // SYN
+                    oneWayLatency +
+                    // SYN ACK
+                    oneWayLatency +
+                    // ACK + initial request
+                    oneWayLatency +
+                    // ClientHello/ServerHello assuming TLS False Start is enabled (https://istlsfastyet.com/#server-performance).
+                    (this.ssl ? twoWayLatency : 0);
+        }
+        let roundTrips = Math.ceil(handshakeAndRequest / twoWayLatency);
+        let timeToFirstByte = handshakeAndRequest + this.serverLatency + oneWayLatency;
+        if (this.warmed && this.h2) {
+            timeToFirstByte = 0;
+        }
+        const timeElapsedForTTFB = Math.max(timeToFirstByte - timeAlreadyElapsed, 0);
+        const maximumDownloadTimeToElapse = maximumTimeToElapse - timeElapsedForTTFB;
+        let congestionWindow = Math.min(this._congestionWindow, maximumCongestionWindow);
+        let totalBytesDownloaded = 0;
+        if (timeElapsedForTTFB > 0) {
+            totalBytesDownloaded = congestionWindow * TCP_SEGMENT_SIZE;
+        }
+        else {
+            roundTrips = 0;
+        }
+        let downloadTimeElapsed = 0;
+        let bytesRemaining = bytesToDownload - totalBytesDownloaded;
+        while (bytesRemaining > 0 && downloadTimeElapsed <= maximumDownloadTimeToElapse) {
+            roundTrips++;
+            downloadTimeElapsed += twoWayLatency;
+            congestionWindow = Math.max(Math.min(maximumCongestionWindow, congestionWindow * 2), 1);
+            const bytesDownloadedInWindow = congestionWindow * TCP_SEGMENT_SIZE;
+            totalBytesDownloaded += bytesDownloadedInWindow;
+            bytesRemaining -= bytesDownloadedInWindow;
+        }
+        const timeElapsed = timeElapsedForTTFB + downloadTimeElapsed;
+        const extraBytesDownloaded = this.h2 ? Math.max(totalBytesDownloaded - bytesToDownload, 0) : 0;
+        const bytesDownloaded = Math.max(Math.min(totalBytesDownloaded, bytesToDownload), 0);
+        let connectionTiming;
+        if (!this.warmed) {
+            connectionTiming = {
+                dnsResolutionTime,
+                connectionTime: handshakeAndRequest - dnsResolutionTime,
+                sslTime: this.ssl ? twoWayLatency : undefined,
+                timeToFirstByte,
+            };
+        }
+        else if (this.h2) {
+            // TODO: timing information currently difficult to model for warm h2 connections.
+            connectionTiming = {
+                timeToFirstByte,
+            };
+        }
+        else {
+            connectionTiming = {
+                connectionTime: handshakeAndRequest,
+                timeToFirstByte,
+            };
+        }
+        return {
+            roundTrips,
+            timeElapsed,
+            bytesDownloaded,
+            extraBytesDownloaded,
+            congestionWindow,
+            connectionTiming,
+        };
+    }
+}
+export { TCPConnection };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/simulation/simulation.js

@@ -0,0 +1,9 @@
+// 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.
+export * from './ConnectionPool.js';
+export * from './Constants.js';
+export * from './DNSCache.js';
+export * from './SimulationTimingMap.js';
+export * from './Simulator.js';
+export * from './TCPConnection.js';

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/types/Lantern.js

@@ -0,0 +1,24 @@
+// 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.
+export const NetworkRequestTypes = {
+    XHR: 'XHR',
+    Fetch: 'Fetch',
+    EventSource: 'EventSource',
+    Script: 'Script',
+    Stylesheet: 'Stylesheet',
+    Image: 'Image',
+    Media: 'Media',
+    Font: 'Font',
+    Document: 'Document',
+    TextTrack: 'TextTrack',
+    WebSocket: 'WebSocket',
+    Other: 'Other',
+    Manifest: 'Manifest',
+    SignedExchange: 'SignedExchange',
+    Ping: 'Ping',
+    Preflight: 'Preflight',
+    CSPViolationReport: 'CSPViolationReport',
+    Prefetch: 'Prefetch',
+    FedCM: 'FedCM',
+};

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/lantern/types/types.js

@@ -0,0 +1,4 @@
+// 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.
+export * from './Lantern.js';

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

@@ -0,0 +1,17 @@
+// Copyright 2022 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 EntityMapper from './EntityMapper.js';
+import * as EventsSerializer from './EventsSerializer.js';
+import * as Extras from './extras/extras.js';
+import * as Handlers from './handlers/handlers.js';
+import * as Helpers from './helpers/helpers.js';
+import * as Insights from './insights/insights.js';
+import * as Lantern from './lantern/lantern.js';
+import * as LanternComputationData from './LanternComputationData.js';
+import * as TraceModel from './ModelImpl.js';
+import * as Name from './Name.js';
+import * as Processor from './Processor.js';
+import * as Styles from './Styles.js';
+import * as Types from './types/types.js';
+export { EntityMapper, EventsSerializer, Extras, Handlers, Helpers, Insights, Lantern, LanternComputationData, Name, Processor, Styles, TraceModel, Types, };

package/build/node_modules/chrome-devtools-frontend/front_end/models/trace/types/Configuration.js

@@ -0,0 +1,18 @@
+// Copyright 2023 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+export const defaults = () => ({
+    includeRuntimeCallStats: false,
+    showAllEvents: false,
+    debugMode: false,
+    maxInvalidationEventsPerEvent: 20,
+    enableAnimationsFrameHandler: false,
+});
+/**
+ * Generates a key that can be used to represent this config in a cache. This is
+ * used mainly in tests, where we want to avoid re-parsing a file if we have
+ * already processed it with the same configuration.
+ */
+export function configToCacheKey(config) {
+    return JSON.stringify(config);
+}