chrome-ai-bridge 1.0.2 → 1.0.4

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

@@ -9,11 +9,13 @@ export class StackTraceImpl extends Common.ObjectWrapper.ObjectWrapper {
         super();
         this.syncFragment = syncFragment;
         this.asyncFragments = asyncFragments;
-        syncFragment.stackTraces.add(this);
+        const fragment = syncFragment instanceof DebuggableFragmentImpl ? syncFragment.fragment : syncFragment;
+        fragment.stackTraces.add(this);
         this.asyncFragments.forEach(asyncFragment => asyncFragment.fragment.stackTraces.add(this));
     }
 }
 export class FragmentImpl {
+    static EMPTY_FRAGMENT = new FragmentImpl();
     node;
     stackTraces = new Set();
     /**
@@ -31,6 +33,9 @@ export class FragmentImpl {
         this.node = node;
     }
     get frames() {
+        if (!this.node) {
+            return [];
+        }
         const frames = [];
         for (const node of this.node.getCallStack()) {
             frames.push(...node.frames);
@@ -65,3 +70,67 @@ export class FrameImpl {
         this.missingDebugInfo = missingDebugInfo;
     }
 }
+/**
+ * A DebuggableFragmentImpl wraps an existing FragmentImpl. This is important: We can pause at the
+ * same location multiple times and the paused information changes each and everytime while the underlying
+ * FragmentImpl will stay the same.
+ */
+export class DebuggableFragmentImpl {
+    fragment;
+    callFrames;
+    constructor(fragment, callFrames) {
+        this.fragment = fragment;
+        this.callFrames = callFrames;
+    }
+    get frames() {
+        if (!this.fragment.node) {
+            return [];
+        }
+        const frames = [];
+        let index = 0;
+        for (const node of this.fragment.node.getCallStack()) {
+            for (const [inlineIdx, frame] of node.frames.entries()) {
+                // Create virtual frames for inlined frames.
+                const sdkFrame = inlineIdx === 0 ? this.callFrames[index] :
+                    this.callFrames[index].createVirtualCallFrame(inlineIdx, frame.name ?? '');
+                frames.push(new DebuggableFrameImpl(frame, sdkFrame));
+            }
+            index++;
+        }
+        return frames;
+    }
+}
+/**
+ * A DebuggableFrameImpl wraps an existing FrameImpl. This is important: We can pause at the
+ * same location multiple times and the paused information changes each and everytime while the underlying
+ * FrameImpl will stay the same.
+ */
+export class DebuggableFrameImpl {
+    #frame;
+    #sdkFrame;
+    constructor(frame, sdkFrame) {
+        this.#frame = frame;
+        this.#sdkFrame = sdkFrame;
+    }
+    get url() {
+        return this.#frame.url;
+    }
+    get uiSourceCode() {
+        return this.#frame.uiSourceCode;
+    }
+    get name() {
+        return this.#frame.name;
+    }
+    get line() {
+        return this.#frame.line;
+    }
+    get column() {
+        return this.#frame.column;
+    }
+    get missingDebugInfo() {
+        return this.#frame.missingDebugInfo;
+    }
+    get sdkFrame() {
+        return this.#sdkFrame;
+    }
+}

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

@@ -1,10 +1,12 @@
 // Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+var _a;
+import * as Common from '../../core/common/common.js';
 import * as SDK from '../../core/sdk/sdk.js';
 // eslint-disable-next-line @devtools/es-modules-import
 import * as StackTrace from './stack_trace.js';
-import { AsyncFragmentImpl, FragmentImpl, FrameImpl, StackTraceImpl } from './StackTraceImpl.js';
+import { AsyncFragmentImpl, DebuggableFragmentImpl, FragmentImpl, FrameImpl, StackTraceImpl } from './StackTraceImpl.js';
 import { Trie } from './Trie.js';
 /**
  * The {@link StackTraceModel} is a thin wrapper around a fragment trie.
@@ -13,54 +15,103 @@ import { Trie } from './Trie.js';
  */
 export class StackTraceModel extends SDK.SDKModel.SDKModel {
     #trie = new Trie();
+    #mutex = new Common.Mutex.Mutex();
     /** @returns the {@link StackTraceModel} for the target, or the model for the primaryPageTarget when passing null/undefined */
     static #modelForTarget(target) {
-        const model = (target ?? SDK.TargetManager.TargetManager.instance().primaryPageTarget())?.model(StackTraceModel);
+        const model = (target ?? SDK.TargetManager.TargetManager.instance().primaryPageTarget())?.model(_a);
         if (!model) {
             throw new Error('Unable to find StackTraceModel');
         }
         return model;
     }
     async createFromProtocolRuntime(stackTrace, rawFramesToUIFrames) {
-        const translatePromises = [];
-        const fragment = this.#createFragment(stackTrace.callFrames);
-        translatePromises.push(this.#translateFragment(fragment, rawFramesToUIFrames));
+        const [syncFragment, asyncFragments] = await Promise.all([
+            this.#createFragment(stackTrace.callFrames, rawFramesToUIFrames),
+            this.#createAsyncFragments(stackTrace, rawFramesToUIFrames),
+        ]);
+        return new StackTraceImpl(syncFragment, asyncFragments);
+    }
+    async createFromDebuggerPaused(pausedDetails, rawFramesToUIFrames) {
+        const [syncFragment, asyncFragments] = await Promise.all([
+            this.#createDebuggableFragment(pausedDetails, rawFramesToUIFrames),
+            this.#createAsyncFragments(pausedDetails, rawFramesToUIFrames),
+        ]);
+        return new StackTraceImpl(syncFragment, asyncFragments);
+    }
+    /** Trigger re-translation of all fragments with the provide script in their call stack */
+    async scriptInfoChanged(script, translateRawFrames) {
+        const release = await this.#mutex.acquire();
+        try {
+            const translatePromises = [];
+            let stackTracesToUpdate = new Set();
+            for (const fragment of this.#affectedFragments(script)) {
+                // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
+                // is re-translated as a side-effect.
+                // We just need to remember the stack traces of the skipped over fragments, so we can send the
+                // UPDATED event also to them.
+                if (fragment.node?.children.length === 0) {
+                    translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+                }
+                stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
+            }
+            await Promise.all(translatePromises);
+            for (const stackTrace of stackTracesToUpdate) {
+                stackTrace.dispatchEventToListeners("UPDATED" /* StackTrace.StackTrace.Events.UPDATED */);
+            }
+        }
+        finally {
+            release();
+        }
+    }
+    async #createDebuggableFragment(pausedDetails, rawFramesToUIFrames) {
+        const fragment = await this.#createFragment(pausedDetails.callFrames.map(frame => ({
+            scriptId: frame.script.scriptId,
+            url: frame.script.sourceURL,
+            functionName: frame.functionName,
+            lineNumber: frame.location().lineNumber,
+            columnNumber: frame.location().columnNumber,
+        })), rawFramesToUIFrames);
+        return new DebuggableFragmentImpl(fragment, pausedDetails.callFrames);
+    }
+    async #createAsyncFragments(stackTraceOrPausedEvent, rawFramesToUIFrames) {
         const asyncFragments = [];
         const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel);
         if (debuggerModel) {
-            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTrace)) {
-                const model = StackTraceModel.#modelForTarget(target);
-                const asyncFragment = model.#createFragment(asyncStackTrace.callFrames);
-                translatePromises.push(model.#translateFragment(asyncFragment, rawFramesToUIFrames));
-                asyncFragments.push(new AsyncFragmentImpl(asyncStackTrace.description ?? '', asyncFragment));
+            for await (const { stackTrace: asyncStackTrace, target } of debuggerModel.iterateAsyncParents(stackTraceOrPausedEvent)) {
+                if (asyncStackTrace.callFrames.length === 0) {
+                    // Skip empty async fragments, they don't add value.
+                    continue;
+                }
+                const model = _a.#modelForTarget(target);
+                const asyncFragmentPromise = model.#createFragment(asyncStackTrace.callFrames, rawFramesToUIFrames)
+                    .then(fragment => new AsyncFragmentImpl(asyncStackTrace.description ?? '', fragment));
+                asyncFragments.push(asyncFragmentPromise);
             }
         }
-        await Promise.all(translatePromises);
-        return new StackTraceImpl(fragment, asyncFragments);
+        return await Promise.all(asyncFragments);
     }
-    /** Trigger re-translation of all fragments with the provide script in their call stack */
-    async scriptInfoChanged(script, translateRawFrames) {
-        const translatePromises = [];
-        let stackTracesToUpdate = new Set();
-        for (const fragment of this.#affectedFragments(script)) {
-            // We trigger re-translation only for fragments of leaf-nodes. Any fragment along the ancestor-chain
-            // is re-translated as a side-effect.
-            // We just need to remember the stack traces of the skipped over fragments, so we can send the
-            // UPDATED event also to them.
-            if (fragment.node.children.length === 0) {
-                translatePromises.push(this.#translateFragment(fragment, translateRawFrames));
+    async #createFragment(frames, rawFramesToUIFrames) {
+        if (frames.length === 0) {
+            return FragmentImpl.EMPTY_FRAGMENT;
+        }
+        const release = await this.#mutex.acquire();
+        try {
+            const node = this.#trie.insert(frames);
+            const requiresTranslation = !Boolean(node.fragment);
+            const fragment = FragmentImpl.getOrCreate(node);
+            if (requiresTranslation) {
+                await this.#translateFragment(fragment, rawFramesToUIFrames);
             }
-            stackTracesToUpdate = stackTracesToUpdate.union(fragment.stackTraces);
+            return fragment;
         }
-        await Promise.all(translatePromises);
-        for (const stackTrace of stackTracesToUpdate) {
-            stackTrace.dispatchEventToListeners("UPDATED" /* StackTrace.StackTrace.Events.UPDATED */);
+        finally {
+            release();
         }
     }
-    #createFragment(frames) {
-        return FragmentImpl.getOrCreate(this.#trie.insert(frames));
-    }
     async #translateFragment(fragment, rawFramesToUIFrames) {
+        if (!fragment.node) {
+            return;
+        }
         const rawFrames = fragment.node.getCallStack().map(node => node.rawFrame).toArray();
         const uiFrames = await rawFramesToUIFrames(rawFrames, this.target());
         console.assert(rawFrames.length === uiFrames.length, 'Broken rawFramesToUIFrames implementation');
@@ -94,4 +145,5 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel {
         return fragments;
     }
 }
+_a = StackTraceModel;
 SDK.SDKModel.SDKModel.register(StackTraceModel, { capabilities: 0 /* SDK.Target.Capability.NONE */, autostart: false });

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

@@ -13,9 +13,14 @@ export class EventsSerializer {
             return `${"l" /* Types.File.EventKeyType.LEGACY_TIMELINE_FRAME */}-${event.index}`;
         }
         const rawEvents = Helpers.SyntheticEvents.SyntheticEventsManager.getActiveManager().getRawTraceEvents();
+        const isSynthetic = Types.Events.isSyntheticBased(event);
+        const index = rawEvents.indexOf(isSynthetic ? event.rawSourceEvent : event);
+        if (index === -1) {
+            throw new Error(`Unknown trace event: ${event.name}`);
+        }
         const key = Types.Events.isSyntheticBased(event) ?
-            `${"s" /* Types.File.EventKeyType.SYNTHETIC_EVENT */}-${rawEvents.indexOf(event.rawSourceEvent)}` :
-            `${"r" /* Types.File.EventKeyType.RAW_EVENT */}-${rawEvents.indexOf(event)}`;
+            `${"s" /* Types.File.EventKeyType.SYNTHETIC_EVENT */}-${index}` :
+            `${"r" /* Types.File.EventKeyType.RAW_EVENT */}-${index}`;
         if (key.length < 3) {
             return null;
         }

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

@@ -3,12 +3,12 @@
 // found in the LICENSE file.
 import * as Handlers from './handlers/handlers.js';
 import * as Lantern from './lantern/lantern.js';
-function createProcessedNavigation(data, frameId, navigationId) {
+function createProcessedNavigation(data, frameId, navigation) {
     const scoresByNav = data.PageLoadMetrics.metricScoresByFrameId.get(frameId);
     if (!scoresByNav) {
         throw new Lantern.Core.LanternError('missing metric scores for frame');
     }
-    const scores = scoresByNav.get(navigationId);
+    const scores = scoresByNav.get(navigation);
     if (!scores) {
         throw new Lantern.Core.LanternError('missing metric scores for specified navigation');
     }

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

@@ -212,7 +212,7 @@ export class TraceProcessor extends EventTarget {
         }
         return this.#insights;
     }
-    #createLanternContext(data, traceEvents, frameId, navigationId, options) {
+    #createLanternContext(data, traceEvents, frameId, navigation, options) {
         // Check for required handlers.
         if (!data.NetworkRequests || !data.Workers || !data.PageLoadMetrics) {
             return;
@@ -221,7 +221,7 @@ export class TraceProcessor extends EventTarget {
             throw new Lantern.Core.LanternError('No network requests found in trace');
         }
         const navStarts = data.Meta.navigationsByFrameId.get(frameId);
-        const navStartIndex = navStarts?.findIndex(n => n.args.data?.navigationId === navigationId);
+        const navStartIndex = navStarts?.findIndex(n => n === navigation);
         if (!navStarts || navStartIndex === undefined || navStartIndex === -1) {
             throw new Lantern.Core.LanternError('Could not find navigation start');
         }
@@ -235,7 +235,7 @@ export class TraceProcessor extends EventTarget {
         };
         const requests = LanternComputationData.createNetworkRequests(trace, data, startTime, endTime);
         const graph = LanternComputationData.createGraph(requests, trace, data);
-        const processedNavigation = LanternComputationData.createProcessedNavigation(data, frameId, navigationId);
+        const processedNavigation = LanternComputationData.createProcessedNavigation(data, frameId, navigation);
         const networkAnalysis = Lantern.Core.NetworkAnalyzer.analyze(requests);
         if (!networkAnalysis) {
             return;
@@ -304,10 +304,10 @@ export class TraceProcessor extends EventTarget {
         const observedInpScore = Insights.Common.evaluateINPMetricScore(observedInp);
         const observedClsScore = Insights.Common.evaluateCLSMetricScore(observedCls);
         const insightToSortingRank = new Map();
-        for (const [name, model] of Object.entries(insightSet.model)) {
-            const lcp = model.metricSavings?.LCP ?? 0;
-            const inp = model.metricSavings?.INP ?? 0;
-            const cls = model.metricSavings?.CLS ?? 0;
+        for (const [name, insight] of Object.entries(insightSet.model)) {
+            const lcp = insight.metricSavings?.LCP ?? 0;
+            const inp = insight.metricSavings?.INP ?? 0;
+            const cls = insight.metricSavings?.CLS ?? 0;
             const lcpPostSavings = observedLcp !== undefined ? Math.max(0, observedLcp - lcp) : undefined;
             const inpPostSavings = Math.max(0, observedInp - inp);
             const clsPostSavings = Math.max(0, observedCls - cls);
@@ -365,28 +365,28 @@ export class TraceProcessor extends EventTarget {
             urlString = data.Meta.finalDisplayUrlByNavigationId.get('') ?? data.Meta.mainFrameURL;
         }
         const insightSetModel = {};
+        const insightSetModelErrors = {};
         for (const [name, insight] of Object.entries(_a.getInsightRunners())) {
-            let model;
             try {
                 logger?.start(`insights:${name}`);
-                model = insight.generateInsight(data, context);
+                const model = insight.generateInsight(data, context);
                 model.frameId = context.frameId;
                 const navId = context.navigation?.args.data?.navigationId;
                 if (navId) {
-                    model.navigationId = navId;
+                    model.navigation = context.navigation;
                 }
                 model.createOverlays = () => {
                     // @ts-expect-error: model is a union of all possible insight model types.
                     return insight.createOverlays(model);
                 };
+                Object.assign(insightSetModel, { [name]: model });
             }
             catch (err) {
-                model = err;
+                Object.assign(insightSetModelErrors, { [name]: err });
             }
             finally {
                 logger?.end(`insights:${name}`);
             }
-            Object.assign(insightSetModel, { [name]: model });
         }
         // We may choose to exclude the insightSet if it's trivial. Trivial means:
         //   1. There's no navigation (it's an initial trace period)
@@ -396,12 +396,10 @@ export class TraceProcessor extends EventTarget {
         // Generally, these cases are the short time ranges before a page reload starts.
         const isNavigation = id === Types.Events.NO_NAVIGATION;
         const trivialThreshold = Helpers.Timing.milliToMicro(Types.Timing.Milli(5000));
-        const everyInsightPasses = Object.values(insightSetModel)
-            .filter(model => !(model instanceof Error))
-            .every(model => model.state === 'pass');
-        const noLcp = !insightSetModel.LCPBreakdown.lcpEvent;
-        const noInp = !insightSetModel.INPBreakdown.longestInteractionEvent;
-        const noLayoutShifts = insightSetModel.CLSCulprits.shifts?.size === 0;
+        const everyInsightPasses = Object.values(insightSetModel).every(model => model && model.state === 'pass');
+        const noLcp = !insightSetModel.LCPBreakdown?.lcpEvent;
+        const noInp = !insightSetModel.INPBreakdown?.longestInteractionEvent;
+        const noLayoutShifts = insightSetModel.CLSCulprits?.shifts?.size === 0;
         const shouldExclude = isNavigation && context.bounds.range < trivialThreshold && everyInsightPasses && noLcp &&
             noInp && noLayoutShifts;
         if (shouldExclude) {
@@ -423,6 +421,7 @@ export class TraceProcessor extends EventTarget {
             frameId: context.frameId,
             bounds: context.bounds,
             model: insightSetModel,
+            modelErrors: insightSetModelErrors,
         };
         this.#insights.set(insightSet.id, insightSet);
         this.sortInsightSet(insightSet, context.options.metadata ?? null);
@@ -474,7 +473,7 @@ export class TraceProcessor extends EventTarget {
         let lantern;
         try {
             options.logger?.start('insights:createLanternContext');
-            lantern = this.#createLanternContext(data, traceEvents, frameId, navigationId, options);
+            lantern = this.#createLanternContext(data, traceEvents, frameId, navigation, options);
         }
         catch (e) {
             // Handle Lantern errors gracefully

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

@@ -307,6 +307,10 @@ const UIStrings = {
      * @description Text in Timeline UIUtils of the Performance panel
      */
     largestContentfulPaint: 'Largest Contentful Paint',
+    /**
+     * @description Text in Timeline UIUtils of the Performance panel
+     */
+    softLargestContentfulPaint: 'Soft Largest Contentful Paint',
     /**
      * @description Text for timestamps of items
      */
@@ -684,6 +688,7 @@ export function maybeInitSylesMap() {
         ["firstPaint" /* Types.Events.Name.MARK_FIRST_PAINT */]: new TimelineRecordStyle(i18nString(UIStrings.firstPaint), defaultCategoryStyles.painting, true),
         ["firstContentfulPaint" /* Types.Events.Name.MARK_FCP */]: new TimelineRecordStyle(i18nString(UIStrings.firstContentfulPaint), defaultCategoryStyles.rendering, true),
         ["largestContentfulPaint::Candidate" /* Types.Events.Name.MARK_LCP_CANDIDATE */]: new TimelineRecordStyle(i18nString(UIStrings.largestContentfulPaint), defaultCategoryStyles.rendering, true),
+        ["largestContentfulPaint::CandidateForSoftNavigation" /* Types.Events.Name.MARK_LCP_CANDIDATE_FOR_SOFT_NAVIGATION */]: new TimelineRecordStyle(i18nString(UIStrings.softLargestContentfulPaint), defaultCategoryStyles.rendering, true),
         ["TimeStamp" /* Types.Events.Name.TIME_STAMP */]: new TimelineRecordStyle(i18nString(UIStrings.timestamp), defaultCategoryStyles.scripting),
         ["ConsoleTime" /* Types.Events.Name.CONSOLE_TIME */]: new TimelineRecordStyle(i18nString(UIStrings.consoleTime), defaultCategoryStyles.scripting),
         ["UserTiming" /* Types.Events.Name.USER_TIMING */]: new TimelineRecordStyle(i18nString(UIStrings.userTiming), defaultCategoryStyles.scripting),
@@ -795,13 +800,16 @@ export function markerDetailsForEvent(event) {
         color = 'var(--sys-color-green-bright)';
         title = "FCP" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP */;
     }
-    if (Types.Events.isLargestContentfulPaintCandidate(event)) {
+    if (Types.Events.isAnyLargestContentfulPaintCandidate(event)) {
         color = 'var(--sys-color-green)';
-        title = "LCP" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.LCP */;
+        title = Types.Events.isSoftLargestContentfulPaintCandidate(event) ?
+            "LCP*" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.SOFT_LCP */ :
+            "LCP" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.LCP */;
     }
-    if (Types.Events.isNavigationStart(event)) {
+    if (Types.Events.isNavigationStart(event) || Types.Events.isSoftNavigationStart(event)) {
         color = 'var(--color-text-primary)';
-        title = "Nav" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.NAV */;
+        title = Types.Events.isSoftNavigationStart(event) ? "Nav*" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.SOFT_NAV */ :
+            "Nav" /* Handlers.ModelHandlers.PageLoadMetrics.MetricName.NAV */;
     }
     if (Types.Events.isMarkDOMContent(event)) {
         color = 'var(--color-text-disabled)';

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

@@ -0,0 +1,46 @@
+import { get as getStackTrace } from './StackTraceForEvent.js';
+/**
+ * There are bugs in the backend tracing that means that network requests are
+ * often incorrectly tied to an initiator. This function exists as a utility to
+ * look up an event's initiator regardless of the type of event, but also to
+ * provide a post-parsing fix for network initiators.
+ * The TL;DR is that images injected by a script will incorrectly have their
+ * initiator set to the root document. To fix this, we look at the stack trace
+ * when the request was sent, and use that.
+ */
+export function getNetworkInitiator(data, event) {
+    const networkHandlerInitiator = data.NetworkRequests.incompleteInitiator.get(event);
+    if (networkHandlerInitiator?.args.data.mimeType === 'text/css') {
+        // The bugs in tracing & initiators apply mostly to scripts; we have not
+        // seen a case where the trace events identify a CSS stylesheet as the
+        // initiator that is incorrect. Therefore, if a stylesheet is identified as
+        // the initiator, we trust that it is accurate and can exit early.
+        return networkHandlerInitiator;
+    }
+    // For network requests, it is more reliable to calculate the initiator via
+    // the stack trace if we have one.
+    // We have to use the raw source event (`ResourceSendRequest`) as that is
+    // the event with the `sampleStackId` property which is required to
+    // calculate this stacktrace correctly.
+    const stack = getStackTrace(event.rawSourceEvent, data);
+    // If the resource was injected by a script, it will have a parent call
+    // frame that points to the script. Otherwise, there is no parent and
+    // therefore we fallthrough to looking at the initiator directly on the
+    // network request.
+    const initiatorCallFrame = stack?.parent?.callFrames.at(0);
+    if (!initiatorCallFrame) {
+        return networkHandlerInitiator;
+    }
+    // Find all the requests for the URL we are searching for. Most of the time
+    // there is only 1, but there can be multiple requests for the same URL. The
+    // filtering by the timestamp ensures that we can never pick an initiator
+    // that happened after the initiated event.
+    const matchingRequestIds = data.NetworkRequests.requestIdsByURL.get(initiatorCallFrame.url) ?? [];
+    const matchingRequests = matchingRequestIds.map(id => data.NetworkRequests.byId.get(id))
+        .filter(req => req !== undefined)
+        .filter(req => req.ts < event.ts);
+    // Now we have filtered and have a list of requests that are before the
+    // event, we take the last one - the one closest to the initiated event.
+    // In the case that there are >1 requests, this is an educated guess.
+    return matchingRequests.at(-1);
+}

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

@@ -413,8 +413,9 @@ export class BottomUpRootNode extends Node {
                 node.totalTime += totalTimeById.get(id) || 0;
                 totalTimeById.delete(id);
             }
-            // TODO: this may be wrong. See the skipped test in TraceTree.test.ts.
-            if (firstNodeStack.length) {
+            // An item on this stack means that this current node has a caller. Therefore,
+            // in a bottom-up view it has children.
+            if (idStack.length > 0) {
                 node.setHasChildren(true);
             }
         }
@@ -587,7 +588,7 @@ export function generateEventID(event) {
             SamplesIntegrator.nativeGroup(event.callFrame.functionName) :
             event.callFrame.functionName;
         const location = event.callFrame.scriptId || event.callFrame.url || '';
-        return `f:${name}@${location}`;
+        return `f:${name}@${location}:${event.callFrame.lineNumber}:${event.callFrame.columnNumber}`;
     }
     if (Types.Events.isConsoleTimeStamp(event) && event.args.data) {
         return `${event.name}:${event.args.data.name}`;

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

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 export * as FilmStrip from './FilmStrip.js';
+export * as Initiators from './Initiators.js';
 export * as MainThreadActivity from './MainThreadActivity.js';
 export * as ScriptDuplication from './ScriptDuplication.js';
 export * as StackTraceForEvent from './StackTraceForEvent.js';

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

@@ -43,9 +43,9 @@ export async function finalize() {
     const { traceBounds, navigationsByNavigationId } = metaData();
     const metricScoresByFrameId = pageLoadMetricsData().metricScoresByFrameId;
     for (const [navigationId, navigation] of navigationsByNavigationId) {
-        const lcpMetric = metricScoresByFrameId.get(navigation.args.frame)?.get(navigationId)?.get("LCP" /* MetricName.LCP */);
+        const lcpMetric = metricScoresByFrameId.get(navigation.args.frame)?.get(navigation)?.get("LCP" /* MetricName.LCP */);
         const lcpEvent = lcpMetric?.event;
-        if (!lcpEvent || !Types.Events.isLargestContentfulPaintCandidate(lcpEvent)) {
+        if (!lcpEvent || !Types.Events.isAnyLargestContentfulPaintCandidate(lcpEvent)) {
             continue;
         }
         const nodeId = lcpEvent.args.data?.nodeId;

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

@@ -395,7 +395,7 @@ async function buildLayoutShiftsClusters() {
         // Update the cluster's worst layout shift.
         if (worstShiftEvent) {
             cluster.worstShiftEvent = worstShiftEvent;
-            cluster.rawSourceEvent = worstShiftEvent;
+            cluster.rawSourceEvent = worstShiftEvent.rawSourceEvent;
         }
         // layout shifts are already sorted by time ascending.
         // Capture the time range of the cluster.

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

@@ -47,6 +47,7 @@ let traceBounds = makeNewTraceBounds();
  */
 let navigationsByFrameId = new Map();
 let navigationsByNavigationId = new Map();
+let softNavigationsById = new Map();
 let finalDisplayUrlByNavigationId = new Map();
 let mainFrameNavigations = [];
 // Represents all the threads in the trace, organized by process. This is mostly for internal
@@ -76,6 +77,7 @@ const CHROME_WEB_TRACE_EVENTS = new Set([
 export function reset() {
     navigationsByFrameId = new Map();
     navigationsByNavigationId = new Map();
+    softNavigationsById = new Map();
     finalDisplayUrlByNavigationId = new Map();
     processNames = new Map();
     mainFrameNavigations = [];
@@ -276,6 +278,9 @@ export function handleEvent(event) {
         }
         return;
     }
+    if (Types.Events.isSoftNavigationStart(event)) {
+        softNavigationsById.set(event.args.context.performanceTimelineNavigationId, event);
+    }
     // Update `finalDisplayUrlByNavigationId` to reflect the latest redirect for each navigation.
     if (Types.Events.isResourceSendRequest(event)) {
         if (event.args.data.resourceType !== 'Document') {
@@ -393,6 +398,7 @@ export function data() {
         mainFrameURL,
         navigationsByFrameId,
         navigationsByNavigationId,
+        softNavigationsById,
         finalDisplayUrlByNavigationId,
         threadsInProcess,
         rendererProcessesByFrame: rendererProcessesByFrameId,

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

@@ -13,6 +13,10 @@ let linkPreconnectEvents = [];
 let requestMap = new Map();
 let requestsById = new Map();
 let requestsByTime = [];
+/**
+ * URL => RequestId[]. There can be multiple requests for a single URL.
+ */
+let requestIdsByURL = new Map();
 let networkRequestEventByInitiatorUrl = new Map();
 let eventToInitiatorMap = new Map();
 /**
@@ -61,6 +65,7 @@ export function reset() {
     networkRequestEventByInitiatorUrl = new Map();
     eventToInitiatorMap = new Map();
     webSocketData = new Map();
+    requestIdsByURL = new Map();
     entityMappings = {
         eventsByEntity: new Map(),
         entityByEvent: new Map(),
@@ -476,6 +481,9 @@ export async function finalize() {
         // the captured requests, so here we store all of them together.
         requestsByTime.push(networkEvent);
         requestsById.set(networkEvent.args.data.requestId, networkEvent);
+        const requestsForUrl = requestIdsByURL.get(networkEvent.args.data.url) ?? [];
+        requestsForUrl.push(networkEvent.args.data.requestId);
+        requestIdsByURL.set(networkEvent.args.data.url, requestsForUrl);
         // Update entity relationships for network events
         HandlerHelpers.addNetworkRequestToEntityMapping(networkEvent, entityMappings, request);
         // Establish initiator relationships
@@ -501,7 +509,8 @@ export function data() {
     return {
         byId: requestsById,
         byTime: requestsByTime,
-        eventToInitiator: eventToInitiatorMap,
+        requestIdsByURL,
+        incompleteInitiator: eventToInitiatorMap,
         webSocket: [...webSocketData.values()],
         entityMappings: {
             entityByEvent: entityMappings.entityByEvent,