lighthouse 13.5.0-dev.20261016 → 13.5.0-dev.20261019

package/.agents/skills/update-trace-engine/SKILL.md

@@ -0,0 +1,154 @@
+---
+name: update-trace-engine
+description: Build, validate, publish, and roll @paulirish/trace_engine from devtools-frontend into Lighthouse. Invoke when asked to update or roll the trace_engine package.
+---
+
+# Update `@paulirish/trace_engine`
+
+Lighthouse consumes Chrome DevTools' trace processor (`front_end/models/trace`) via the standalone `@paulirish/trace_engine` npm package, built from the `trace-engine-lib` branch of `paulirish/devtools-frontend`.
+
+## What lives where
+
+| Location | Purpose | Notes |
+|---|---|---|
+| `devtools-frontend` checkout (branch `trace-engine-lib`) | Source & packaging scripts | Tracks `origin/main` (`https://chromium.googlesource.com/devtools/devtools-frontend`) + packaging scripts in `scripts/trace/`. Common local path: `~/devtools/devtools-frontend` (ask user if not found). |
+| `scripts/trace/prep-trace-engine-package.sh` (in `devtools-frontend`) | Builds `out/TraceEngine` and prepares standalone package | Converts `export const enum` → `export enum` in `front_end/models/trace/**/*.ts`, builds with `gn` + `autoninja`, applies shims from `scripts/trace/replacements/`, extracts insight locale strings, and invokes `copy-build-trace-engine-for-publish.sh`. |
+| `scripts/trace/copy-build-trace-engine-for-publish.sh` (in `devtools-frontend`) | Copies dist to `$HOME/code/trace_engine` and tests | Copies `out/TraceEngine/dist` to `$HOME/code/trace_engine`, runs `npm install` and `npm test` (Mocha tests in `test/test-trace-engine.mjs` + `tsc --build ./tsconfig.json`). |
+| `$HOME/code/trace_engine` | Standalone npm package staging directory | Where `npm version` and `npm publish` are run. |
+| `core/lib/trace-engine.js` (in Lighthouse) | Lighthouse entry point for `@paulirish/trace_engine` | Re-exports `TraceProcessor`, `TraceHandlers`, `Insights`, `Helpers`, and `Types`. |
+
+## Procedure
+
+### 1. Merge `origin/main` into `trace-engine-lib` in `devtools-frontend`
+
+1. Find the previous `devtools-frontend` `main` commit SHA from the most recent `deps: upgrade trace_engine` commit or PR in Lighthouse (or via `git log -n 1 --merges --pretty=format:"%P"` on `trace-engine-lib`).
+2. In the `devtools-frontend` checkout:
+   ```sh
+   git checkout trace-engine-lib
+   git fetch origin main
+   git merge origin/main --no-edit
+   ```
+3. Record the commit range `<old_sha>...<new_sha>` and inspect upstream changes:
+   ```sh
+   git log --oneline <old_sha>..<new_sha> -- front_end/models/trace front_end/models/cpu_profile
+   ```
+4. If there are merge conflicts in `front_end/models/trace/**/*.ts` due to `export const enum` vs `export enum`, resolve in favor of `origin/main` — `prep-trace-engine-package.sh` automatically converts `export const enum` to `export enum`.
+
+### 2. Build and test the standalone package
+
+Ensure `depot_tools` (`gn`, `autoninja`) and Node/npm are on `PATH`, then run:
+
+```sh
+scripts/trace/prep-trace-engine-package.sh
+```
+
+This builds `out/TraceEngine`, populates `$HOME/code/trace_engine`, and runs `npm test` (`mocha` + `tsc --build ./tsconfig.json`).
+
+#### Fixing build or test failures in `trace-engine-lib`
+
+- **TypeScript (`tsc --build ./tsconfig.json`) errors in `$HOME/code/trace_engine`**:
+  - `prep-trace-engine-package.sh` replaces several DevTools modules using `scripts/trace/replacements/` so Lighthouse can bundle `trace_engine` into an IIFE (`esbuild`) and defer localization (`LH.IcuMessage`):
+    - `HostRuntime.js`: synchronous stub replacing top-level `await` in `core/platform/HostRuntime.js`.
+    - `UIString.d.ts` & `i18n.{js,d.ts}`: types `LocalizedString` as a deferred `{i18nId, values}` object instead of a branded `string`. If a file in `core/platform/` (such as `UserVisibleError.d.ts`) fails type-checking because it expects `LocalizedString` to be assignable to `string` and isn't needed by `models/trace`, stub its `.d.ts` in `prep-trace-engine-package.sh` (`echo 'export {};' > "$dist/core/platform/<File>.d.ts"`).
+    - `common.{js,d.ts}`, `sdk.d.ts`, `crux-manager.d.ts`: minimal stubs for `core/common`, `core/sdk`, and `models/crux-manager`. Update these if `models/trace` references new symbols from those modules.
+- **Mocha (`test/test-trace-engine.mjs`) failures**:
+  - If an assertion in `scripts/trace/test/test-trace-engine.mjs` fails due to an intentional upstream calculation change in `front_end/models/trace`, update `scripts/trace/test/test-trace-engine.mjs` and re-run `scripts/trace/copy-build-trace-engine-for-publish.sh`.
+- Commit any updated files on `trace-engine-lib` and push to Paul's fork (`git push paulirish trace-engine-lib`) when requested.
+
+### 3. Bump the package version
+
+Determine the next patch version (`0.0.X` → `0.0.(X+1)`) from `package.json` in Lighthouse or `npm view @paulirish/trace_engine version --registry https://registry.npmjs.org/`:
+
+```sh
+cd $HOME/code/trace_engine
+npm version v0.0.XXX --no-git-tag-version
+```
+
+### 4. Validate locally in Lighthouse before publishing
+
+Copy the built package into Lighthouse's `node_modules/@paulirish/trace_engine` to validate before publishing to npm:
+
+```sh
+rm -rf node_modules/@paulirish/trace_engine/{models,core,generated,third_party,locales,test}
+cp -rp $HOME/code/trace_engine/{models,core,generated,third_party,locales,package.json,tsconfig.json} node_modules/@paulirish/trace_engine/
+```
+
+Run the Lighthouse validation checks:
+
+1. **Type-checking**:
+   ```sh
+   yarn type-check
+   ```
+   Fix any Lighthouse code or JSDoc types broken by upstream `TraceEngine` API/type changes (commonly in `core/audits/insights/`, `core/computed/`, `core/gather/gatherers/trace-elements.js`, or `core/lib/trace-engine.js`).
+
+2. **Bundles**:
+   ```sh
+   yarn build-devtools && yarn build-lr && yarn build-devtools-mcp
+   ```
+   Confirms `esbuild` can bundle `trace_engine` into IIFE (`dt-bundle.js`, Lightrider) and ESM without top-level `await` or missing module errors.
+
+3. **Unit tests**:
+   ```sh
+   yarn mocha core/test/audits/insights/*-test.js core/test/audits/metrics-test.js core/test/audits/predictive-perf-test.js core/test/audits/byte-efficiency/byte-efficiency-audit-test.js core/test/computed/metrics/*-test.js core/test/computed/trace-engine-result-test.js core/test/computed/navigation-insights-test.js core/test/computed/entity-classification-test.js core/test/computed/tbt-impact-tasks-test.js
+   INTERNAL_LANTERN_USE_TRACE=1 yarn mocha core/test/computed/metrics/*-test.js core/test/audits/metrics-test.js core/test/audits/predictive-perf-test.js
+   ```
+   Update test expectations and snapshots (`yarn mocha --update <test-file>`) where upstream changes intentionally affect metrics, insights, or Lantern trace simulations.
+
+4. **Sample JSON, locale strings, flow fixtures, and Lantern baselines**:
+   ```sh
+   yarn update:sample-json
+   bash core/scripts/assert-baseline-flow-result-unchanged.sh
+   yarn test-lantern
+   ```
+   - If `assert-baseline-flow-result-unchanged.sh` fails due to expected changes, update flow fixtures with `yarn update:flow-fixtures`.
+   - If `yarn test-lantern` reports expected metric changes on the Lantern dataset (or if `models/trace/lantern` changed upstream), update the Lantern baseline files (`core/test/fixtures/lantern-baseline-computed-values.json` and `core/test/fixtures/lantern-baseline-accuracy.json`):
+     ```sh
+     FORCE=1 ./core/scripts/lantern/update-baseline-lantern-values.js
+     ./core/scripts/lantern/assert-baseline-lantern-values-unchanged.js
+     ```
+   - Review `git diff core/test/results/sample_v2.json` and `git diff shared/localization/locales/en-US.json` to make sure every change is accounted for by an upstream commit.
+
+5. **Linter**:
+   ```sh
+   yarn lint --fix
+   ```
+
+### 5. Pause for npm publish
+
+Once local validation passes, pause and ask the user to publish `$HOME/code/trace_engine` to npm (requires interactive npm authentication):
+
+```sh
+cd $HOME/code/trace_engine
+npm publish --access public --registry https://registry.npmjs.org/
+```
+
+### 6. Roll `package.json`, `yarn.lock`, and open the PR
+
+After the user confirms `@paulirish/trace_engine@0.0.XXX` is published on npm:
+
+1. Update `"@paulirish/trace_engine": "0.0.XXX"` in `package.json` and run `yarn` to update `yarn.lock`.
+2. Commit all changes (`deps: upgrade trace_engine to 0.0.XXX`).
+3. Run `yarn diff:sample-json` after committing (note: `assert-strings-collected.sh` runs `git diff --exit-code shared/localization/locales/`, so uncommitted locale changes will cause it to fail).
+4. Push the branch and open a PR against `GoogleChrome/lighthouse` with title `deps: upgrade trace_engine to 0.0.XXX` and description formatted like [PR #17307](https://github.com/GoogleChrome/lighthouse/pull/17307) (including the collapsible `<details><summary>` block with the full `git log <old_sha>...<new_sha> -- front_end/models/trace` output):
+
+````markdown
+Roll `@paulirish/trace_engine` from `0.0.OLD` to `0.0.NEW` (`<old_sha>...<new_sha>`).
+
+https://chromium.googlesource.com/devtools/devtools-frontend.git/+log/<old_sha>..<new_sha>
+
+### Highlights for Lighthouse
+
+- **<Category>**:
+  - **<Highlight>** ([CL <cl_number>](https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/<cl_number>)): <summary of upstream change and impact on Lighthouse>
+
+`git log <old_sha>...<new_sha> -- front_end/models/trace`:
+
+<details>
+  <summary>Changelog (just front_end/models/trace, mostly relevant to our usage in LH)</summary>
+
+```
+<full output of: git log <old_sha>...<new_sha> -- front_end/models/trace>
+```
+
+</details>
+````

package/commitlint.config.js

@@ -4,7 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-module.exports = {
+export default {
   extends: ['cz'],
   rules: {
     'body-leading-blank': [1, 'always'],

package/core/audits/insights/insight-audit.js

@@ -6,6 +6,7 @@
 
 import {NO_NAVIGATION} from '@paulirish/trace_engine/models/trace/types/TraceEvents.js';
 
+import {Helpers} from '../../lib/trace-engine.js';
 import {ProcessedTrace} from '../../computed/processed-trace.js';
 import {TraceEngineResult} from '../../computed/trace-engine-result.js';
 import {Audit} from '../audit.js';
@@ -28,8 +29,8 @@ async function getInsightSet(artifacts, context) {
 
   const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
   const insights = navigationId ?
-    [...traceEngineResult.insights.values()]
-      .find(insightSet => insightSet.navigation?.args.data?.navigationId === navigationId) :
+    [...traceEngineResult.insights.values()].find(insightSet =>
+      Helpers.Trace.navigationIDForEvent(insightSet.navigation) === navigationId) :
     traceEngineResult.insights.get(NO_NAVIGATION);
 
   return {insights, data: traceEngineResult.data};

package/core/computed/metrics/time-to-first-byte.js

@@ -6,6 +6,7 @@
 
 import {calculateDocFirstByteTs} from '@paulirish/trace_engine/models/trace/insights/Common.js';
 
+import {Helpers} from '../../lib/trace-engine.js';
 import {makeComputedArtifact} from '../computed-artifact.js';
 import {NavigationMetric} from './navigation-metric.js';
 import {MainResource} from '../main-resource.js';
@@ -52,15 +53,16 @@ class TimeToFirstByte extends NavigationMetric {
       await NavigationInsights.request({trace, settings, SourceMaps, HostDPR}, context);
     const lcpBreakdown = navInsights.model.LCPBreakdown;
 
+    const navigationId = Helpers.Trace.navigationIDForEvent(navInsights.navigation);
+
     // Defer to LCP breakdown, but if there's no LCP fallback to manual calculation.
     if (lcpBreakdown && !(lcpBreakdown instanceof Error) && lcpBreakdown.subparts) {
       return {
         timing: lcpBreakdown.subparts.ttfb.range / 1000,
         timestamp: lcpBreakdown.subparts.ttfb.max,
       };
-    } else if (navInsights.navigation?.args.data?.navigationId) {
-      const request = traceEngineResult.data.NetworkRequests.byId.get(
-        navInsights.navigation.args.data.navigationId);
+    } else if (navInsights.navigation && navigationId) {
+      const request = traceEngineResult.data.NetworkRequests.byId.get(navigationId);
       if (!request) {
         throw new Error();
       }

package/core/computed/navigation-insights.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
+import {Helpers} from '../lib/trace-engine.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {ProcessedTrace} from './processed-trace.js';
 import {TraceEngineResult} from './trace-engine-result.js';
@@ -26,8 +27,8 @@ class NavigationInsights {
     const navigationId = processedTrace.timeOriginEvt.args.data?.navigationId;
     if (!navigationId) throw new Error('No navigationId found');
 
-    const navInsights = [...traceEngineResult.insights.values()]
-        .find(insightSet => insightSet.navigation?.args.data?.navigationId === navigationId);
+    const navInsights = [...traceEngineResult.insights.values()].find(insightSet =>
+      Helpers.Trace.navigationIDForEvent(insightSet.navigation) === navigationId);
     if (!navInsights) throw new Error('No navigations insights found');
 
     return navInsights;

package/core/computed/trace-engine-result.js

@@ -7,6 +7,7 @@
 import log from 'lighthouse-logger';
 
 import * as i18n from '../lib/i18n/i18n.js';
+import * as Lantern from '../lib/lantern/lantern.js';
 import * as TraceEngine from '../lib/trace-engine.js';
 import {makeComputedArtifact} from './computed-artifact.js';
 import {CumulativeLayoutShift} from './metrics/cumulative-layout-shift.js';
@@ -68,8 +69,20 @@ class TraceEngineResult {
     });
     if (!processor.data) throw new Error('No data');
     if (!processor.insights) throw new Error('No insights');
-    this.localizeInsights(processor.insights);
-    return {data: processor.data, insights: processor.insights};
+    const data = processor.data;
+    const insights = processor.insights;
+    this.localizeInsights(insights);
+
+    // Release intermediate handler state retained in module-level TraceHandlers singletons
+    // and static Lantern simulation node timings after trace processing completes.
+    for (const handler of Object.values(TraceEngine.TraceHandlers)) {
+      handler.reset();
+    }
+    if (!process.env.LANTERN_DEBUG) {
+      Lantern.Simulation.Simulator.allNodeTimings.clear();
+    }
+
+    return {data, insights};
   }
 
   /**
@@ -238,8 +251,9 @@ class TraceEngineResult {
     const layoutShiftEvents = new Set(
       CumulativeLayoutShift.getLayoutShiftEvents(processedTrace).map(e => e.event));
 
-    // Avoid modifying the input array.
-    const traceEvents = [...data.trace.traceEvents];
+    // Avoid modifying the input array, copying only if an event is modified.
+    let traceEvents = data.trace.traceEvents;
+    let copied = false;
     for (let i = 0; i < traceEvents.length; i++) {
       let event = traceEvents[i];
       if (event.name !== 'LayoutShift') continue;
@@ -247,6 +261,10 @@ class TraceEngineResult {
 
       const isConsidered = layoutShiftEvents.has(event);
       if (event.args.data.had_recent_input && isConsidered) {
+        if (!copied) {
+          traceEvents = [...traceEvents];
+          copied = true;
+        }
         event = JSON.parse(JSON.stringify(event));
         // @ts-expect-error impossible for data to be missing.
         event.args.data.had_recent_input = false;

package/core/config/config-helpers.js

@@ -13,7 +13,6 @@ import ConfigPlugin from './config-plugin.js';
 import {Runner} from '../runner.js';
 import * as i18n from '../lib/i18n/i18n.js';
 import * as validation from './validation.js';
-import {getModuleDirectory} from '../../shared/esm-utils.js';
 import {isEqual} from '../lib/arbitrary-equality-map.js';
 
 const require = createRequire(import.meta.url);
@@ -292,7 +291,7 @@ function requireAudit(auditPath, coreAuditList, configDir) {
       const absolutePath = resolveModulePath(auditPath, configDir, 'audit');
       if (isBundledEnvironment()) {
         // Use a relative path so bundler can easily expose it.
-        requirePath = path.relative(getModuleDirectory(import.meta), absolutePath);
+        requirePath = path.relative(import.meta.dirname, absolutePath);
       } else {
         requirePath = absolutePath;
       }
@@ -512,7 +511,7 @@ function resolveModulePath(moduleIdentifier, configDir, category) {
   const errorString = 'Unable to locate ' + (category ? `${category}: ` : '') +
     `\`${moduleIdentifier}\`.
      Tried to resolve the module from these locations:
-       ${getModuleDirectory(import.meta)}
+       ${import.meta.dirname}
        ${cwdPath}`;
 
   if (!configDir) {

package/core/config/config.js

@@ -28,11 +28,10 @@ import {
   mergeConfigFragment,
   mergeConfigFragmentArrayByKey,
 } from './config-helpers.js';
-import {getModuleDirectory} from '../../shared/esm-utils.js';
 import * as format from '../../shared/localization/format.js';
 
 const defaultConfigPath = path.join(
-  getModuleDirectory(import.meta),
+  import.meta.dirname,
   '../../config/default-config.js'
 );
 

package/core/gather/gatherers/inspector-issues.js

@@ -96,6 +96,8 @@ class InspectorIssues extends BaseGatherer {
       }
     }
 
+    this._issues = [];
+
     return artifact;
   }
 }

package/core/gather/gatherers/js-usage.js

@@ -67,6 +67,8 @@ class JsUsage extends BaseGatherer {
       usageByScriptId[scriptUsage.scriptId] = scriptUsage;
     }
 
+    this._scriptUsages = [];
+
     return usageByScriptId;
   }
 }

package/core/gather/gatherers/scripts.d.ts

@@ -1,13 +1,22 @@
 export default Scripts;
+export type TraceScript = {
+    scriptId: string;
+    sourceText?: string | undefined;
+    chunks?: string[] | undefined;
+    url?: string | undefined;
+    sourceUrl?: string | undefined;
+    executionContextId?: number | undefined;
+    frame?: string | undefined;
+};
 /**
  * @fileoverview Gets JavaScript file contents.
  */
 declare class Scripts extends BaseGatherer {
     static symbol: symbol;
+    /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
+    meta: LH.Gatherer.GathererMeta<"Trace">;
     /** @type {LH.Crdp.Debugger.ScriptParsedEvent[]} */
     _scriptParsedEvents: LH.Crdp.Debugger.ScriptParsedEvent[];
-    /** @type {Array<string | undefined>} */
-    _scriptContents: Array<string | undefined>;
     /**
      * @param {LH.Crdp.Debugger.ScriptParsedEvent} params
      */
@@ -20,7 +29,11 @@ declare class Scripts extends BaseGatherer {
      * @param {LH.Gatherer.Context} context
      */
     stopInstrumentation(context: LH.Gatherer.Context): Promise<void>;
-    getArtifact(): Promise<import("../../index.js").Artifacts.Script[]>;
+    /**
+     * @param {LH.Gatherer.Context<'Trace'>} context
+     * @return {Promise<LH.Artifacts['Scripts']>}
+     */
+    getArtifact(context: LH.Gatherer.Context<"Trace">): Promise<LH.Artifacts["Scripts"]>;
 }
 import BaseGatherer from '../base-gatherer.js';
 //# sourceMappingURL=scripts.d.ts.map

package/core/gather/gatherers/scripts.js

@@ -5,19 +5,31 @@
  */
 
 import BaseGatherer from '../base-gatherer.js';
+import Trace from './trace.js';
+
+/**
+ * @typedef {Object} TraceScript
+ * @property {string} scriptId
+ * @property {string} [sourceText]
+ * @property {string[]} [chunks]
+ * @property {string} [url]
+ * @property {string} [sourceUrl]
+ * @property {number} [executionContextId]
+ * @property {string} [frame]
+ */
 
 /**
  * @template T, U
  * @param {Array<T>} values
- * @param {(value: T) => Promise<U>} promiseMapper
+ * @param {(value: T, index: number) => Promise<U>} promiseMapper
  * @param {boolean} runInSeries
  * @return {Promise<Array<U>>}
  */
 async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   if (runInSeries) {
     const results = [];
-    for (const value of values) {
-      const result = await promiseMapper(value);
+    for (let i = 0; i < values.length; i++) {
+      const result = await promiseMapper(values[i], i);
       results.push(result);
     }
     return results;
@@ -27,6 +39,121 @@ async function runInSeriesOrParallel(values, promiseMapper, runInSeries) {
   }
 }
 
+/**
+ * Extracts script source text and disambiguating metadata from trace rundown events,
+ * grouped by `scriptId`.
+ * @param {LH.TraceEvent[]} traceEvents
+ * @return {Map<string, TraceScript[]>}
+ */
+function collectTraceScripts(traceEvents) {
+  /** @type {Map<string, TraceScript>} */
+  const byIsolateAndScriptId = new Map();
+
+  /**
+   * @param {NonNullable<LH.TraceEvent['args']['data']>} data
+   * @return {TraceScript}
+   */
+  const getOrCreateRecord = (data) => {
+    const scriptId = String(data.scriptId);
+    const key = `${data.isolate ?? ''}.${scriptId}`;
+    let record = byIsolateAndScriptId.get(key);
+    if (!record) {
+      record = {scriptId};
+      byIsolateAndScriptId.set(key, record);
+    }
+    return record;
+  };
+
+  for (const event of traceEvents) {
+    const data = event.args?.data;
+    if (!data || data.scriptId === undefined) continue;
+
+    if (event.cat === 'disabled-by-default-devtools.target-rundown') {
+      if (typeof data.frame === 'string') {
+        getOrCreateRecord(data).frame = data.frame;
+      }
+    } else if (event.cat === 'disabled-by-default-devtools.v8-source-rundown' &&
+        event.name === 'ScriptCatchup') {
+      const record = getOrCreateRecord(data);
+      if (typeof data.url === 'string') record.url = data.url;
+      if (typeof data.sourceUrl === 'string') record.sourceUrl = data.sourceUrl;
+      if (typeof data.executionContextId === 'number') {
+        record.executionContextId = data.executionContextId;
+      }
+    } else if (event.cat === 'disabled-by-default-devtools.v8-source-rundown-sources' &&
+        typeof data.sourceText === 'string') {
+      const record = getOrCreateRecord(data);
+      if (event.name === 'ScriptCatchup') {
+        record.sourceText = data.sourceText;
+      } else if (event.name === 'LargeScriptCatchup') {
+        if (!record.chunks || data.splitIndex === 0) record.chunks = [];
+        record.chunks.push(data.sourceText);
+      }
+    }
+  }
+
+  /** @type {Map<string, TraceScript[]>} */
+  const byScriptId = new Map();
+  for (const record of byIsolateAndScriptId.values()) {
+    if (record.chunks) record.sourceText = record.chunks.join('');
+    if (record.sourceText === undefined) continue;
+
+    let list = byScriptId.get(record.scriptId);
+    if (!list) {
+      list = [];
+      byScriptId.set(record.scriptId, list);
+    }
+    list.push(record);
+  }
+
+  return byScriptId;
+}
+
+/**
+ * @param {TraceScript} traceScript
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ * @return {boolean}
+ */
+function matchesScriptParsedEvent(traceScript, script) {
+  const frameId = script.executionContextAuxData?.frameId;
+  if (frameId && traceScript.frame !== undefined && traceScript.frame !== frameId) {
+    return false;
+  }
+  const scriptUrl = script.embedderName || script.url;
+  if (traceScript.url !== undefined &&
+      traceScript.url !== scriptUrl &&
+      traceScript.sourceUrl !== script.url) {
+    return false;
+  }
+  if (script.executionContextId !== undefined &&
+      traceScript.executionContextId !== undefined &&
+      traceScript.executionContextId !== script.executionContextId) {
+    return false;
+  }
+  return true;
+}
+
+/**
+ * @param {LH.Crdp.Debugger.ScriptParsedEvent} script
+ * @param {Map<string, TraceScript[]>} traceScriptsByScriptId
+ * @return {string|undefined}
+ */
+function findTraceScriptSource(script, traceScriptsByScriptId) {
+  const candidates = traceScriptsByScriptId.get(script.scriptId);
+  if (!candidates) return undefined;
+
+  const matches = candidates.filter((candidate) => matchesScriptParsedEvent(candidate, script));
+  if (matches.length === 1) return matches[0].sourceText;
+
+  const frameId = script.executionContextAuxData?.frameId;
+  if (matches.length > 1 && frameId) {
+    const frameMatches = matches.filter((candidate) => candidate.frame === frameId);
+    if (frameMatches.length === 1) return frameMatches[0].sourceText;
+  }
+
+  return undefined;
+}
+
 /**
  * Returns true if the script was created via our own calls
  * to Runtime.evaluate.
@@ -50,18 +177,16 @@ function isLighthouseRuntimeEvaluateScript(script) {
 class Scripts extends BaseGatherer {
   static symbol = Symbol('Scripts');
 
-  /** @type {LH.Gatherer.GathererMeta} */
+  /** @type {LH.Gatherer.GathererMeta<'Trace'>} */
   meta = {
     symbol: Scripts.symbol,
     supportedModes: ['timespan', 'navigation'],
+    dependencies: {Trace: Trace.symbol},
   };
 
   /** @type {LH.Crdp.Debugger.ScriptParsedEvent[]} */
   _scriptParsedEvents = [];
 
-  /** @type {Array<string | undefined>} */
-  _scriptContents = [];
-
   constructor() {
     super();
     this.onScriptParsed = this.onScriptParsed.bind(this);
@@ -89,26 +214,42 @@ class Scripts extends BaseGatherer {
    * @param {LH.Gatherer.Context} context
    */
   async stopInstrumentation(context) {
+    const session = context.driver.defaultSession;
+    session.off('Debugger.scriptParsed', this.onScriptParsed);
+  }
+
+  /**
+   * @param {LH.Gatherer.Context<'Trace'>} context
+   * @return {Promise<LH.Artifacts['Scripts']>}
+   */
+  async getArtifact(context) {
     const session = context.driver.defaultSession;
     const formFactor = context.baseArtifacts.HostFormFactor;
+    const traceScriptsByScriptId = collectTraceScripts(context.dependencies.Trace.traceEvents);
+    const traceSources = this._scriptParsedEvents.map(
+      (script) => findTraceScriptSource(script, traceScriptsByScriptId)
+    );
 
-    session.off('Debugger.scriptParsed', this.onScriptParsed);
+    if (traceSources.some((source) => source === undefined)) {
+      // `disableAsyncStacks()` in `prepare.js` runs after `stopInstrumentation` and calls
+      // `Debugger.disable`, so re-enable `Debugger` if we need to call `Debugger.getScriptSource`.
+      await session.sendCommand('Debugger.enable');
+    }
 
     // If run on a mobile device, be sensitive to memory limitations and only
     // request one at a time.
-    this._scriptContents = await runInSeriesOrParallel(
+    const scriptContents = await runInSeriesOrParallel(
       this._scriptParsedEvents,
-      ({scriptId}) => {
-        return session.sendCommand('Debugger.getScriptSource', {scriptId})
+      (script, i) => {
+        if (traceSources[i] !== undefined) return Promise.resolve(traceSources[i]);
+        return session.sendCommand('Debugger.getScriptSource', {scriptId: script.scriptId})
           .then((resp) => resp.scriptSource)
           .catch(() => undefined);
       },
       formFactor === 'mobile' /* runInSeries */
     );
     await session.sendCommand('Debugger.disable');
-  }
 
-  async getArtifact() {
     /** @type {LH.Artifacts['Scripts']} */
     const scripts = this._scriptParsedEvents.map((event, i) => {
       // 'embedderName' and 'url' are confusingly named, so we rewrite them here.
@@ -123,10 +264,12 @@ class Scripts extends BaseGatherer {
         // embedderName is optional on the protocol because backends like Node may not set it.
         // For our purposes, it is always set. But just in case it isn't... fallback to the url.
         url: event.embedderName || event.url,
-        content: this._scriptContents[i],
+        content: scriptContents[i],
       };
     });
 
+    this._scriptParsedEvents = [];
+
     return scripts;
   }
 }

package/core/gather/gatherers/stylesheets.js

@@ -82,6 +82,8 @@ class Stylesheets extends BaseGatherer {
 
     // Ensure we finish fetching all stylesheet contents before disabling the CSS domain
     const sheets = await Promise.all(this._sheetPromises.values());
+    this._sheetPromises.clear();
+    this._session = undefined;
 
     await session.sendCommand('CSS.disable');
     await session.sendCommand('DOM.disable');

package/core/gather/gatherers/trace-elements.js

@@ -21,6 +21,7 @@ import {ProcessedTrace} from '../../computed/processed-trace.js';
 import {Responsiveness} from '../../computed/metrics/responsiveness.js';
 import {CumulativeLayoutShift} from '../../computed/metrics/cumulative-layout-shift.js';
 import {TraceEngineResult} from '../../computed/trace-engine-result.js';
+import {Helpers} from '../../lib/trace-engine.js';
 import SourceMaps from './source-maps.js';
 
 /** @typedef {{nodeId: number, animations?: {name?: string, failureReasonsMask?: number, unsupportedProperties?: string[]}[], type?: string}} TraceElementData */
@@ -80,7 +81,7 @@ class TraceElements extends BaseGatherer {
     }
 
     if (navigationId) {
-      if (insightSet.navigation?.args.data?.navigationId !== navigationId) {
+      if (Helpers.Trace.navigationIDForEvent(insightSet.navigation) !== navigationId) {
         return [];
       }
     } else {

package/core/lib/cdt/Common.d.ts

@@ -1,3 +1,3 @@
 export { ParsedURL };
-import ParsedURL = require("./generated/ParsedURL.js");
+import * as ParsedURL from './generated/ParsedURL.js';
 //# sourceMappingURL=Common.d.ts.map