chrome-devtools-frontend 1.0.1402249 → 1.0.1418433

package/front_end/models/trace/lantern/graph/PageDependencyGraph.test.ts

@@ -2,39 +2,43 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// @ts-nocheck TODO(crbug.com/348449529)
-
 import * as Lantern from '../lantern.js';
 
 const {NetworkRequestTypes} = Lantern.Types;
 const {PageDependencyGraph} = Lantern.Graph;
 
 function createRequest(
-    requestId,
-    url,
+    requestId: number,
+    url: string,
     rendererStartTime = 0,
-    initiator = null,
-    resourceType = NetworkRequestTypes.Document,
+    initiator: null|Partial<Lantern.Types.NetworkRequest['initiator']> = null,
+    resourceType: keyof typeof NetworkRequestTypes = NetworkRequestTypes.Document,
     fromWorker = false,
-    ): Lantern.NetworkRequest {
+    ): Lantern.Types.NetworkRequest {
   const networkEndTime = rendererStartTime + 50;
   return {
-    requestId,
+    requestId: String(requestId),
     url,
     rendererStartTime,
     networkEndTime,
     initiator,
     resourceType,
     fromWorker,
-  };
+  } as unknown as Lantern.Types.NetworkRequest;
 }
 
+const getDependencyIds = (node: Lantern.Graph.Node): string[] => node.getDependencies().map(node => node.id);
+
 const TOPLEVEL_TASK_NAME = 'TaskQueueManager::ProcessTaskFromWorkQueue';
 describe('PageDependencyGraph', () => {
-  let traceEvents;
-  let url;
-
-  function addTaskEvents(startTs, duration, evts) {
+  let traceEvents: Lantern.Types.TraceEvent[] = [];
+  let url: Lantern.Types.Simulation.URL;
+
+  function addTaskEvents(startTs: number, duration: number, evts: Array<{
+                           name: string,
+                           ts?: number,
+                           data?: unknown,
+                         }>) {
     const mainEvent = {
       name: TOPLEVEL_TASK_NAME,
       tid: 1,
@@ -43,16 +47,16 @@ describe('PageDependencyGraph', () => {
       args: {},
     };
 
-    traceEvents.push(mainEvent);
+    traceEvents.push(mainEvent as Lantern.Types.TraceEvent);
 
     let i = 0;
     for (const evt of evts) {
       i++;
       traceEvents.push({
         name: evt.name,
-        ts: (evt.ts * 1000) || (startTs * 1000 + i),
+        ts: typeof evt.ts === 'number' ? (evt.ts * 1000) : NaN || (startTs * 1000 + i),
         args: {data: evt.data},
-      });
+      } as Lantern.Types.TraceEvent);
     }
   }
 
@@ -72,7 +76,7 @@ describe('PageDependencyGraph', () => {
       for (let i = 0; i < networkRequests.length; i++) {
         const node = networkNodeOutput.nodes[i];
         assert.isOk(node, `did not create node at index ${i}`);
-        assert.strictEqual(node.id, i + 1);
+        assert.strictEqual(node.id, String(i + 1));
         assert.strictEqual(node.type, 'network');
         assert.strictEqual(node.request, networkRequests[i]);
       }
@@ -95,7 +99,7 @@ describe('PageDependencyGraph', () => {
       const networkNodeOutput = PageDependencyGraph.getNetworkNodeOutput(networkRequests);
       const indexedById = networkNodeOutput.idToNodeMap;
       for (const request of networkRequests) {
-        assert.strictEqual(indexedById.get(request.requestId).request, request);
+        assert.strictEqual(indexedById.get(request.requestId)?.request, request);
       }
     });
 
@@ -217,11 +221,11 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -237,7 +241,7 @@ describe('PageDependencyGraph', () => {
 
       addTaskEvents(200, 200, [
         {name: 'EvaluateScript', data: {url: 'https://example.com/page'}},
-        {name: 'ResourceSendRequest', data: {requestId: 4}},
+        {name: 'ResourceSendRequest', data: {requestId: '4'}},
       ]);
 
       addTaskEvents(700, 50, [
@@ -246,20 +250,19 @@ describe('PageDependencyGraph', () => {
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
-      const getIds = nodes => nodes.map(node => node.id);
-      const getDependencyIds = node => getIds(node.getDependencies());
+      const getIds = (nodes: Lantern.Graph.Node[]): string[] => nodes.map(node => node.id);
 
       assert.lengthOf(nodes, 6);
-      assert.deepEqual(getIds(nodes), [1, 2, 3, 4, '1.200000', '1.700000']);
+      assert.deepEqual(getIds(nodes), ['1', '2', '3', '4', '1.200000', '1.700000']);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
-      assert.deepEqual(getDependencyIds(nodes[1]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[2]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[3]), [1, '1.200000']);
-      assert.deepEqual(getDependencyIds(nodes[4]), [2]);
-      assert.deepEqual(getDependencyIds(nodes[5]), [3, 4]);
+      assert.deepEqual(getDependencyIds(nodes[1]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[2]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[3]), ['1', '1.200000']);
+      assert.deepEqual(getDependencyIds(nodes[4]), ['2']);
+      assert.deepEqual(getDependencyIds(nodes[5]), ['3', '4']);
     });
 
     it('should compute a network graph with duplicate URLs', () => {
@@ -272,11 +275,11 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -296,7 +299,7 @@ describe('PageDependencyGraph', () => {
         {name: 'EvaluateScript', data: {url: 'https://example.com/'}},
 
         // Network 2 should depend on CPU 1.2, but 1.2 should not depend on Network 1
-        {name: 'ResourceSendRequest', data: {requestId: 2}},
+        {name: 'ResourceSendRequest', data: {requestId: '2'}},
         {name: 'XHRReadyStateChange', data: {readyState: 4, url: 'https://example.com/page'}},
 
         // CPU 1.2 should not depend on Network 3 because it starts after CPU 1.2
@@ -307,23 +310,21 @@ describe('PageDependencyGraph', () => {
         // CPU 1.6 should depend on Network 4 even though it ends at 410ms
         {name: 'InvalidateLayout', data: {stackTrace: [{url: 'https://example.com/page3'}]}},
         // Network 5 should not depend on CPU 1.6 because it started before CPU 1.6
-        {name: 'ResourceSendRequest', data: {requestId: 5}},
+        {name: 'ResourceSendRequest', data: {requestId: '5'}},
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
-      const getDependencyIds = node => node.getDependencies().map(node => node.id);
-
       assert.lengthOf(nodes, 7);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
-      assert.deepEqual(getDependencyIds(nodes[1]), [1, '1.200000']);
-      assert.deepEqual(getDependencyIds(nodes[2]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[3]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[4]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[5]), [1]);
-      assert.deepEqual(getDependencyIds(nodes[6]), [4]);
+      assert.deepEqual(getDependencyIds(nodes[1]), ['1', '1.200000']);
+      assert.deepEqual(getDependencyIds(nodes[2]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[3]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[4]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[5]), ['1']);
+      assert.deepEqual(getDependencyIds(nodes[6]), ['4']);
     });
 
     it('should not install timer dependency on itself', () => {
@@ -339,14 +340,12 @@ describe('PageDependencyGraph', () => {
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
-      const getDependencyIds = node => node.getDependencies().map(node => node.id);
-
       assert.lengthOf(nodes, 2);
       assert.deepEqual(getDependencyIds(nodes[0]), []);
-      assert.deepEqual(getDependencyIds(nodes[1]), [1]);
+      assert.deepEqual(getDependencyIds(nodes[1]), ['1']);
     });
 
     it('should prune short tasks', () => {
@@ -361,33 +360,31 @@ describe('PageDependencyGraph', () => {
       // Long task, should be kept in the output.
       addTaskEvents(120, 50, [
         {name: 'EvaluateScript', data: {url: 'https://example.com/'}},
-        {name: 'ResourceSendRequest', data: {requestId: 2}},
+        {name: 'ResourceSendRequest', data: {requestId: '2'}},
         {name: 'XHRReadyStateChange', data: {readyState: 4, url: 'https://example.com/page'}},
       ]);
 
       // Short task, should be pruned, but the 3->4 relationship should be retained
       addTaskEvents(350, 5, [
         {name: 'EvaluateScript', data: {url: 'https://example.com/page2'}},
-        {name: 'ResourceSendRequest', data: {requestId: 4}},
+        {name: 'ResourceSendRequest', data: {requestId: '4'}},
         {name: 'XHRReadyStateChange', data: {readyState: 4, url: 'https://example.com/page3'}},
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
-      const getDependencyIds = node => node.getDependencies().map(node => node.id);
-
       assert.lengthOf(nodes, 6);
 
       assert.deepEqual(getDependencyIds(nodes[0]), []);
-      assert.deepEqual(getDependencyIds(nodes[1]), [0]);
-      assert.deepEqual(getDependencyIds(nodes[2]), [0, '1.120000']);
-      assert.deepEqual(getDependencyIds(nodes[3]), [0]);
-      assert.deepEqual(getDependencyIds(nodes[4]), [0, 3]);
+      assert.deepEqual(getDependencyIds(nodes[1]), ['0']);
+      assert.deepEqual(getDependencyIds(nodes[2]), ['0', '1.120000']);
+      assert.deepEqual(getDependencyIds(nodes[3]), ['0']);
+      assert.deepEqual(getDependencyIds(nodes[4]), ['0', '3']);
 
       assert.strictEqual('1.120000', nodes[5].id);
-      assert.deepEqual(getDependencyIds(nodes[5]), [1]);
+      assert.deepEqual(getDependencyIds(nodes[5]), ['1']);
     });
 
     it('should not prune highly-connected short tasks', () => {
@@ -411,29 +408,27 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(220, 5, [
         {name: 'EvaluateScript', data: {url: 'https://example.com/page', frame: 'frame1'}},
 
-        {name: 'ResourceSendRequest', data: {requestId: 3}},
+        {name: 'ResourceSendRequest', data: {requestId: '3'}},
         {name: 'XHRReadyStateChange', data: {readyState: 4, url: 'https://example.com/page2'}},
 
-        {name: 'ResourceSendRequest', data: {requestId: 4}},
+        {name: 'ResourceSendRequest', data: {requestId: '4'}},
         {name: 'XHRReadyStateChange', data: {readyState: 4, url: 'https://example.com/page3'}},
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
-      const getDependencyIds = node => node.getDependencies().map(node => node.id);
-
       assert.lengthOf(nodes, 6);
 
       assert.deepEqual(getDependencyIds(nodes[0]), []);
-      assert.deepEqual(getDependencyIds(nodes[1]), [0]);
-      assert.deepEqual(getDependencyIds(nodes[2]), [0]);
-      assert.deepEqual(getDependencyIds(nodes[3]), [0, '1.220000']);
-      assert.deepEqual(getDependencyIds(nodes[4]), [0, '1.220000']);
+      assert.deepEqual(getDependencyIds(nodes[1]), ['0']);
+      assert.deepEqual(getDependencyIds(nodes[2]), ['0']);
+      assert.deepEqual(getDependencyIds(nodes[3]), ['0', '1.220000']);
+      assert.deepEqual(getDependencyIds(nodes[4]), ['0', '1.220000']);
 
       assert.strictEqual('1.220000', nodes[5].id);
-      assert.deepEqual(getDependencyIds(nodes[5]), [1, 2]);
+      assert.deepEqual(getDependencyIds(nodes[5]), ['1', '2']);
     });
 
     it('should not prune short, first tasks of critical events', () => {
@@ -441,7 +436,7 @@ describe('PageDependencyGraph', () => {
       const networkRequests = [request0];
       url = {requestedUrl: 'https://example.com/page0', mainDocumentUrl: 'https://example.com/page0'};
 
-      const makeShortEvent = firstEventName => {
+      const makeShortEvent = (firstEventName: string) => {
         const startTs = traceEvents.length * 100;
         addTaskEvents(startTs, 5, [
           {name: firstEventName, data: {url: 'https://example.com/page0'}},
@@ -459,7 +454,7 @@ describe('PageDependencyGraph', () => {
       }
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const cpuNodes = [];
+      const cpuNodes: Lantern.Graph.CPUNode[] = [];
       graph.traverse(node => node.type === 'cpu' && cpuNodes.push(node));
 
       expect(cpuNodes.map(node => {
@@ -497,11 +492,11 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 3);
-      assert.strictEqual(nodes[0].id, 1);
+      assert.strictEqual(nodes[0].id, '1');
       assert.isFalse(nodes[0].isMainDocument());
       assert.isTrue(nodes[1].isMainDocument());
       assert.isFalse(nodes[2].isMainDocument());
@@ -518,7 +513,7 @@ describe('PageDependencyGraph', () => {
         stack: {
           callFrames: [{url: 'https://example.com/page'}],
           parent: {parent: {callFrames: [{url: 'https://example.com/page2'}]}},
-        },
+        } as unknown as Lantern.Types.CallStack,
       };
       // Also set the initiatorRequest that Lighthouse's network-recorder.js creates.
       // This should be ignored and only used as a fallback.
@@ -528,11 +523,11 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -549,18 +544,18 @@ describe('PageDependencyGraph', () => {
         stack: {
           callFrames: [{url: 'https://example.com/page'}],
           parent: {parent: {callFrames: [{url: 'https://example.com/page2'}]}},
-        },
+        } as unknown as Lantern.Types.CallStack,
       };
       const networkRequests = [request1, request2, request3, request4];
 
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -575,7 +570,8 @@ describe('PageDependencyGraph', () => {
       // Set the initiator to an ambiguous URL (there are 2 requests for https://a.com/js)
       request3.initiator = {
         type: 'script',
-        stack: {callFrames: [{url: 'https://a.com/js'}], parent: {parent: {callFrames: [{url: 'js'}]}}},
+        stack: {callFrames: [{url: 'https://a.com/js'}], parent: {parent: {callFrames: [{url: 'js'}]}}} as unknown as
+            Lantern.Types.CallStack,
       };
       // Set the initiatorRequest that it should fallback to.
       request3.initiatorRequest = request2Fetch;
@@ -585,11 +581,11 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 4);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3, 4].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[0]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -609,12 +605,12 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
-      nodes.sort((a, b) => a.id - b.id);
+      nodes.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
 
       assert.lengthOf(nodes, 3);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       // We don't know which of the initiators to trust in a cycle, so for now we
       // trust the earliest one (mostly because it's simplest).
@@ -639,12 +635,12 @@ describe('PageDependencyGraph', () => {
       addTaskEvents(0, 0, []);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
-      nodes.sort((a, b) => a.id - b.id);
+      nodes.sort((a, b) => parseInt(a.id, 10) - parseInt(b.id, 10));
 
       assert.lengthOf(nodes, 3);
-      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3]);
+      assert.deepEqual(nodes.map(node => node.id), [1, 2, 3].map(String));
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[1].getDependencies(), [nodes[2]]);
       assert.deepEqual(nodes[2].getDependencies(), [nodes[0]]);
@@ -662,11 +658,11 @@ describe('PageDependencyGraph', () => {
       ]);
 
       const graph = PageDependencyGraph.createGraph(traceEvents, networkRequests, url);
-      const nodes = [];
+      const nodes: Lantern.Graph.Node[] = [];
       graph.traverse(node => nodes.push(node));
 
       assert.lengthOf(nodes, 1);
-      assert.deepEqual(nodes.map(node => node.id), [2]);
+      assert.deepEqual(nodes.map(node => node.id), ['2']);
       assert.deepEqual(nodes[0].getDependencies(), []);
       assert.deepEqual(nodes[0].getDependents(), []);
     });

package/front_end/models/trace/lantern/graph/PageDependencyGraph.ts

@@ -505,7 +505,7 @@ class PageDependencyGraph {
                                                           serverResponseTime: r.serverResponseTime,
                                                         }))
                                                    .filter(r => !r.fromWorker);
-    // eslint-disable-next-line no-unused-vars
+
     const debug = requests;
     // Set breakpoint here.
     // Copy `debug` and compare with https://www.diffchecker.com/text-compare/
@@ -556,6 +556,7 @@ class PageDependencyGraph {
     return rootNode;
   }
 
+  // Unused, but useful for debugging.
   static printGraph(rootNode: Node, widthInCharacters = 100): void {
     function padRight(str: string, target: number, padChar = ' '): string {
       return str + padChar.repeat(Math.max(target - str.length, 0));

package/front_end/models/trace/lantern/metrics/FirstContentfulPaint.ts

@@ -9,7 +9,7 @@ import {Metric, type MetricCoefficients} from './Metric.js';
 
 interface FirstPaintBasedGraphOpts<T> {
   /**
-   * The timestamp used to filter out tasks that occured after our paint of interest.
+   * The timestamp used to filter out tasks that occurred after our paint of interest.
    * Typically this is First Contentful Paint or First Meaningful Paint.
    */
   cutoffTimestamp: number;

package/front_end/models/trace/lantern/simulation/ConnectionPool.test.ts

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// @ts-nocheck TODO(crbug.com/348449529)
-
 import * as Lantern from '../lantern.js';
 
 const {ConnectionPool} = Lantern.Simulation;
@@ -13,30 +11,39 @@ describe('ConnectionPool', () => {
   const throughput = 10000 * 1024;
   let requestId: number;
 
-  function request(data: Partial<Lantern.NetworkRequest> = {}): Lantern.NetworkRequest {
+  function request(data: Partial<Lantern.Types.NetworkRequest> = {}): Lantern.Types.NetworkRequest {
     const url = data.url || 'http://example.com';
     const origin = new URL(url).origin;
     const scheme = url.split(':')[0];
+    const host = new URL(url).hostname;
 
     return {
       requestId: String(requestId++),
       url,
       protocol: 'http/1.1',
-      parsedURL: {scheme, securityOrigin: origin},
+      parsedURL: {scheme, securityOrigin: origin, host},
       ...data,
-    };
+    } as Lantern.Types.NetworkRequest;
   }
 
-  function simulationOptions(options) {
-    return Object.assign(
-        {
-          rtt: 150,
-          throughput: 1024,
-          additionalRttByOrigin: new Map(),
-          serverResponseTimeByOrigin: new Map(),
-        },
-        options,
-    );
+  function simulationOptions(options: {
+    rtt?: number,
+    throughput?: number,
+    additionalRttByOrigin?: Map<string, number>,
+    serverResponseTimeByOrigin?: Map<string, number>,
+  }): Required<Lantern.Types.Simulation.Options> {
+    const defaults: Required<Lantern.Types.Simulation.Options> = {
+      rtt: 150,
+      throughput: 1024,
+      additionalRttByOrigin: new Map(),
+      serverResponseTimeByOrigin: new Map(),
+      // These options are not used by ConnectionPool, but are required in the types.
+      cpuSlowdownMultiplier: 1,
+      layoutTaskMultiplier: 1,
+      observedThroughput: 1,
+      maximumConcurrentRequests: 8,
+    };
+    return Object.assign(defaults, options);
   }
 
   beforeEach(() => {
@@ -47,11 +54,12 @@ describe('ConnectionPool', () => {
     it('should create the pool', () => {
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput}));
       // Make sure 6 connections are created for each origin
-      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com'), 6);
+      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com') ?? [], 6);
       // Make sure it populates connectionWasReused
       assert.isFalse(pool.connectionReusedByRequestId.get('1'));
 
-      const connection = pool.connectionsByOrigin.get('http://example.com')[0];
+      const connection = pool.connectionsByOrigin.get('http://example.com')?.[0];
+      assert.isOk(connection);
       assert.strictEqual(connection.rtt, rtt);
       assert.strictEqual(connection.throughput, throughput);
       assert.strictEqual(connection.serverLatency, 30);  // sets to default value
@@ -60,30 +68,32 @@ describe('ConnectionPool', () => {
     it('should set TLS properly', () => {
       const recordA = request({url: 'https://example.com'});
       const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
-      const connection = pool.connectionsByOrigin.get('https://example.com')[0];
-      assert.isOk(connection.ssl, 'should have set connection TLS');
+      const connection = pool.connectionsByOrigin.get('https://example.com')?.[0];
+      assert.isOk(connection?.ssl, 'should have set connection TLS');
     });
 
     it('should set H2 properly', () => {
       const recordA = request({protocol: 'h2'});
       const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
-      const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.isOk(connection.isH2(), 'should have set HTTP/2');
-      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com'), 1);
+      const connection = pool.connectionsByOrigin.get('http://example.com')?.[0];
+      assert.isOk(connection?.isH2(), 'should have set HTTP/2');
+      assert.lengthOf(pool.connectionsByOrigin.get('http://example.com') ?? [], 1);
     });
 
     it('should set origin-specific RTT properly', () => {
       const additionalRttByOrigin = new Map([['http://example.com', 63]]);
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput, additionalRttByOrigin}));
-      const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.isOk(connection.rtt, rtt + 63);
+      const connection = pool.connectionsByOrigin.get('http://example.com')?.[0];
+      assert.isOk(connection);
+      assert.strictEqual(connection.rtt, rtt + 63);
     });
 
     it('should set origin-specific server latency properly', () => {
       const serverResponseTimeByOrigin = new Map([['http://example.com', 63]]);
       const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput, serverResponseTimeByOrigin}));
-      const connection = pool.connectionsByOrigin.get('http://example.com')[0];
-      assert.isOk(connection.serverLatency, 63);
+      const connection = pool.connectionsByOrigin.get('http://example.com')?.[0];
+      assert.isOk(connection);
+      assert.strictEqual(connection.serverLatency, 63);
     });
   });
 
@@ -129,7 +139,7 @@ describe('ConnectionPool', () => {
       assert.isOk(pool.acquire(warmRecord), 'should have acquired connection');
       pool.release(coldRecord);
 
-      for (const connection of pool.connectionsByOrigin.get('http://example.com')) {
+      for (const connection of pool.connectionsByOrigin.get('http://example.com') ?? []) {
         connection.setWarmed(true);
       }
 
@@ -146,7 +156,9 @@ describe('ConnectionPool', () => {
       pool.connectionReusedByRequestId.set(recordB.requestId, true);
       pool.connectionReusedByRequestId.set(recordC.requestId, true);
 
-      const [connectionWarm, connectionWarmer, connectionWarmest] = pool.connectionsByOrigin.get('http://example.com');
+      const connections = pool.connectionsByOrigin.get('http://example.com');
+      assert.isOk(connections);
+      const [connectionWarm, connectionWarmer, connectionWarmest] = connections;
       connectionWarm.setWarmed(true);
       connectionWarm.setCongestionWindow(10);
       connectionWarmer.setWarmed(true);

package/front_end/models/trace/lantern/simulation/ConnectionPool.ts

@@ -10,7 +10,7 @@ import {TCPConnection} from './TCPConnection.js';
 const DEFAULT_SERVER_RESPONSE_TIME = 30;
 const TLS_SCHEMES = ['https', 'wss'];
 
-// Each origin can have 6 simulatenous connections open
+// 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;
 

package/front_end/models/trace/lantern/simulation/DNSCache.test.ts

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// @ts-nocheck - TODO(crbug.com/348449529) requests need to be whole Lantern.NetworkRequest objects
-
 import * as Lantern from '../lantern.js';
 
 const {DNSCache} = Lantern.Simulation;
@@ -12,7 +10,7 @@ const MULTIPLIER = DNSCache.rttMultiplier;
 
 describe('DNSCache', () => {
   let dns: Lantern.Simulation.DNSCache;
-  let request: Lantern.NetworkRequest;
+  let request: Lantern.Types.NetworkRequest;
 
   beforeEach(() => {
     dns = new DNSCache({rtt: 100});
@@ -22,7 +20,7 @@ describe('DNSCache', () => {
         scheme: 'https',
         securityOrigin: '',
       },
-    } as Lantern.NetworkRequest;
+    } as Lantern.Types.NetworkRequest;
   });
 
   describe('.getTimeUntilResolution', () => {
@@ -50,7 +48,7 @@ describe('DNSCache', () => {
 
     it('should cache by domain', () => {
       dns.getTimeUntilResolution(request, {requestedAt: 0, shouldUpdateCache: true});
-      const otherRequest = {parsedURL: {host: 'other-example.com'}};
+      const otherRequest = {parsedURL: {host: 'other-example.com'}} as Lantern.Types.NetworkRequest;
       const resolutionTime = dns.getTimeUntilResolution(otherRequest, {requestedAt: 1000});
       expect(resolutionTime).to.equal(100 * MULTIPLIER);
     });

package/front_end/models/trace/lantern/simulation/DNSCache.ts

@@ -22,8 +22,8 @@ class DNSCache {
     this.resolvedDomainNames = new Map();
   }
 
-  getTimeUntilResolution(request: Lantern.NetworkRequest, options?: {requestedAt: number, shouldUpdateCache: boolean}):
-      number {
+  getTimeUntilResolution(
+      request: Lantern.NetworkRequest, options?: {requestedAt?: number, shouldUpdateCache?: boolean}): number {
     const {requestedAt = 0, shouldUpdateCache = false} = options || {};
 
     const domain = request.parsedURL.host;