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

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

@@ -1,115 +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 Core from '../core/core.js';
-import { TCPConnection } from './TCPConnection.js';
-const DEFAULT_SERVER_RESPONSE_TIME = 30;
-const TLS_SCHEMES = ['https', 'wss'];
-// Each origin can have 6 simultaneous connections open
-// https://cs.chromium.org/chromium/src/net/socket/client_socket_pool_manager.cc?type=cs&q="int+g_max_sockets_per_group"
-const CONNECTIONS_PER_ORIGIN = 6;
-export class ConnectionPool {
-    options;
-    records;
-    connectionsByOrigin;
-    connectionsByRequest;
-    _connectionsInUse;
-    connectionReusedByRequestId;
-    constructor(records, options) {
-        this.options = options;
-        this.records = records;
-        this.connectionsByOrigin = new Map();
-        this.connectionsByRequest = new Map();
-        this._connectionsInUse = new Set();
-        this.connectionReusedByRequestId = Core.NetworkAnalyzer.estimateIfConnectionWasReused(records, {
-            forceCoarseEstimates: true,
-        });
-        this.initializeConnections();
-    }
-    connectionsInUse() {
-        return Array.from(this._connectionsInUse);
-    }
-    initializeConnections() {
-        const connectionReused = this.connectionReusedByRequestId;
-        const additionalRttByOrigin = this.options.additionalRttByOrigin;
-        const serverResponseTimeByOrigin = this.options.serverResponseTimeByOrigin;
-        const recordsByOrigin = Core.NetworkAnalyzer.groupByOrigin(this.records);
-        for (const [origin, requests] of recordsByOrigin.entries()) {
-            const connections = [];
-            const additionalRtt = additionalRttByOrigin.get(origin) || 0;
-            const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;
-            for (const request of requests) {
-                if (connectionReused.get(request.requestId)) {
-                    continue;
-                }
-                const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);
-                const isH2 = request.protocol === 'h2';
-                const connection = new TCPConnection(this.options.rtt + additionalRtt, this.options.throughput, responseTime, isTLS, isH2);
-                connections.push(connection);
-            }
-            if (!connections.length) {
-                throw new Core.LanternError(`Could not find a connection for origin: ${origin}`);
-            }
-            // Make sure each origin has minimum number of connections available for max throughput.
-            // But only if it's not over H2 which maximizes throughput already.
-            const minConnections = connections[0].isH2() ? 1 : CONNECTIONS_PER_ORIGIN;
-            while (connections.length < minConnections) {
-                connections.push(connections[0].clone());
-            }
-            this.connectionsByOrigin.set(origin, connections);
-        }
-    }
-    findAvailableConnectionWithLargestCongestionWindow(connections) {
-        let maxConnection = null;
-        for (let i = 0; i < connections.length; i++) {
-            const connection = connections[i];
-            // Connections that are in use are never available.
-            if (this._connectionsInUse.has(connection)) {
-                continue;
-            }
-            // This connection is a match and is available! Update our max if it has a larger congestionWindow
-            const currentMax = (maxConnection?.congestionWindow) || -Infinity;
-            if (connection.congestionWindow > currentMax) {
-                maxConnection = connection;
-            }
-        }
-        return maxConnection;
-    }
-    /**
-     * This method finds an available connection to the origin specified by the network request or null
-     * if no connection was available. If returned, connection will not be available for other network
-     * records until release is called.
-     */
-    acquire(request) {
-        if (this.connectionsByRequest.has(request)) {
-            throw new Core.LanternError('Record already has a connection');
-        }
-        const origin = request.parsedURL.securityOrigin;
-        const connections = this.connectionsByOrigin.get(origin) || [];
-        const connectionToUse = this.findAvailableConnectionWithLargestCongestionWindow(connections);
-        if (!connectionToUse) {
-            return null;
-        }
-        this._connectionsInUse.add(connectionToUse);
-        this.connectionsByRequest.set(request, connectionToUse);
-        return connectionToUse;
-    }
-    /**
-     * Return the connection currently being used to fetch a request. If no connection
-     * currently being used for this request, an error will be thrown.
-     */
-    acquireActiveConnectionFromRequest(request) {
-        const activeConnection = this.connectionsByRequest.get(request);
-        if (!activeConnection) {
-            throw new Core.LanternError('Could not find an active connection for request');
-        }
-        return activeConnection;
-    }
-    release(request) {
-        const connection = this.connectionsByRequest.get(request);
-        this.connectionsByRequest.delete(request);
-        if (connection) {
-            this._connectionsInUse.delete(connection);
-        }
-    }
-}

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

@@ -1,42 +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.
-const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
-const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
-const throttling = {
-    DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-    DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    // These values align with WebPageTest's definition of "Fast 3G"
-    // But offer similar characteristics to roughly the 75th percentile of 4G connections.
-    mobileSlow4G: {
-        rttMs: 150,
-        throughputKbps: 1.6 * 1024,
-        requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-        downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-        uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-        cpuSlowdownMultiplier: 4,
-    },
-    // These values partially align with WebPageTest's definition of "Regular 3G".
-    // These values are meant to roughly align with Chrome UX report's 3G definition which are based
-    // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.
-    mobileRegular3G: {
-        rttMs: 300,
-        throughputKbps: 700,
-        requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-        downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-        uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-        cpuSlowdownMultiplier: 4,
-    },
-    // Using a "broadband" connection type
-    // Corresponds to "Dense 4G 25th percentile" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v
-    desktopDense4G: {
-        rttMs: 40,
-        throughputKbps: 10 * 1024,
-        cpuSlowdownMultiplier: 1,
-        requestLatencyMs: 0, // 0 means unset
-        downloadThroughputKbps: 0,
-        uploadThroughputKbps: 0,
-    },
-};
-const Constants = { throttling };
-export { Constants };

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

@@ -1,47 +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.
-// A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
-// Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
-// Example: https://www.webpagetest.org/result/180707_1M_89673eb633b5d98386de95dfcf9b33d5/1/details/#waterfall_view_step1
-// DNS is highly variable though, many times it's a little more than 1, but can easily be 4-5x RTT.
-// We'll use 2 since it seems to give the most accurate results on average, but this can be tweaked.
-const DNS_RESOLUTION_RTT_MULTIPLIER = 2;
-class DNSCache {
-    static rttMultiplier = DNS_RESOLUTION_RTT_MULTIPLIER;
-    rtt;
-    resolvedDomainNames;
-    constructor({ rtt }) {
-        this.rtt = rtt;
-        this.resolvedDomainNames = new Map();
-    }
-    getTimeUntilResolution(request, options) {
-        const { requestedAt = 0, shouldUpdateCache = false } = options || {};
-        const domain = request.parsedURL.host;
-        const cacheEntry = this.resolvedDomainNames.get(domain);
-        let timeUntilResolved = this.rtt * DNSCache.rttMultiplier;
-        if (cacheEntry) {
-            const timeUntilCachedIsResolved = Math.max(cacheEntry.resolvedAt - requestedAt, 0);
-            timeUntilResolved = Math.min(timeUntilCachedIsResolved, timeUntilResolved);
-        }
-        const resolvedAt = requestedAt + timeUntilResolved;
-        if (shouldUpdateCache) {
-            this.updateCacheResolvedAtIfNeeded(request, resolvedAt);
-        }
-        return timeUntilResolved;
-    }
-    updateCacheResolvedAtIfNeeded(request, resolvedAt) {
-        const domain = request.parsedURL.host;
-        const cacheEntry = this.resolvedDomainNames.get(domain) || { resolvedAt };
-        cacheEntry.resolvedAt = Math.min(cacheEntry.resolvedAt, resolvedAt);
-        this.resolvedDomainNames.set(domain, cacheEntry);
-    }
-    /**
-     * Forcefully sets the DNS resolution time for a request.
-     * Useful for testing and alternate execution simulations.
-     */
-    setResolvedAt(domain, resolvedAt) {
-        this.resolvedDomainNames.set(domain, { resolvedAt });
-    }
-}
-export { DNSCache };

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

@@ -1,134 +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.
-/**
- * @file
- *
- * This class encapsulates the type-related validation logic for moving timing information for nodes
- * through the different simulation phases. Methods here ensure that the invariants of simulation hold
- * as nodes are queued, partially simulated, and completed.
- */
-import * as Core from '../core/core.js';
-import * as Graph from '../graph/graph.js';
-class SimulatorTimingMap {
-    nodeTimings;
-    constructor() {
-        this.nodeTimings = new Map();
-    }
-    getNodes() {
-        return Array.from(this.nodeTimings.keys());
-    }
-    setReadyToStart(node, values) {
-        this.nodeTimings.set(node, values);
-    }
-    setInProgress(node, values) {
-        const nodeTiming = {
-            ...this.getQueued(node),
-            startTime: values.startTime,
-            timeElapsed: 0,
-        };
-        this.nodeTimings.set(node, node.type === Graph.BaseNode.types.NETWORK ? { ...nodeTiming, timeElapsedOvershoot: 0, bytesDownloaded: 0 } :
-            nodeTiming);
-    }
-    setCompleted(node, values) {
-        const nodeTiming = {
-            ...this.getInProgress(node),
-            endTime: values.endTime,
-            connectionTiming: values.connectionTiming,
-        };
-        this.nodeTimings.set(node, nodeTiming);
-    }
-    setCpu(node, values) {
-        const nodeTiming = {
-            ...this.getCpuStarted(node),
-            timeElapsed: values.timeElapsed,
-        };
-        this.nodeTimings.set(node, nodeTiming);
-    }
-    setCpuEstimated(node, values) {
-        const nodeTiming = {
-            ...this.getCpuStarted(node),
-            estimatedTimeElapsed: values.estimatedTimeElapsed,
-        };
-        this.nodeTimings.set(node, nodeTiming);
-    }
-    setNetwork(node, values) {
-        const nodeTiming = {
-            ...this.getNetworkStarted(node),
-            timeElapsed: values.timeElapsed,
-            timeElapsedOvershoot: values.timeElapsedOvershoot,
-            bytesDownloaded: values.bytesDownloaded,
-        };
-        this.nodeTimings.set(node, nodeTiming);
-    }
-    setNetworkEstimated(node, values) {
-        const nodeTiming = {
-            ...this.getNetworkStarted(node),
-            estimatedTimeElapsed: values.estimatedTimeElapsed,
-        };
-        this.nodeTimings.set(node, nodeTiming);
-    }
-    getQueued(node) {
-        const timing = this.nodeTimings.get(node);
-        if (!timing) {
-            throw new Core.LanternError(`Node ${node.id} not yet queued`);
-        }
-        return timing;
-    }
-    getCpuStarted(node) {
-        const timing = this.nodeTimings.get(node);
-        if (!timing) {
-            throw new Core.LanternError(`Node ${node.id} not yet queued`);
-        }
-        if (!('startTime' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet started`);
-        }
-        if ('bytesDownloaded' in timing) {
-            throw new Core.LanternError(`Node ${node.id} timing not valid`);
-        }
-        return timing;
-    }
-    getNetworkStarted(node) {
-        const timing = this.nodeTimings.get(node);
-        if (!timing) {
-            throw new Core.LanternError(`Node ${node.id} not yet queued`);
-        }
-        if (!('startTime' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet started`);
-        }
-        if (!('bytesDownloaded' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} timing not valid`);
-        }
-        return timing;
-    }
-    getInProgress(node) {
-        const timing = this.nodeTimings.get(node);
-        if (!timing) {
-            throw new Core.LanternError(`Node ${node.id} not yet queued`);
-        }
-        if (!('startTime' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet started`);
-        }
-        if (!('estimatedTimeElapsed' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet in progress`);
-        }
-        return timing;
-    }
-    getCompleted(node) {
-        const timing = this.nodeTimings.get(node);
-        if (!timing) {
-            throw new Core.LanternError(`Node ${node.id} not yet queued`);
-        }
-        if (!('startTime' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet started`);
-        }
-        if (!('estimatedTimeElapsed' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet in progress`);
-        }
-        if (!('endTime' in timing)) {
-            throw new Core.LanternError(`Node ${node.id} not yet completed`);
-        }
-        return timing;
-    }
-}
-export { SimulatorTimingMap };