chrome-ai-bridge 1.0.3 → 1.0.5

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

@@ -141,6 +141,10 @@ export class DebuggerWorkspaceBinding {
         const model = target.model(StackTraceImpl.StackTraceModel.StackTraceModel);
         return await model.createFromProtocolRuntime(stackTrace, this.#translateRawFrames.bind(this));
     }
+    async createStackTraceFromDebuggerPaused(pausedDetails, target) {
+        const model = target.model(StackTraceImpl.StackTraceModel.StackTraceModel);
+        return await model.createFromDebuggerPaused(pausedDetails, this.#translateRawFrames.bind(this));
+    }
     async createLiveLocation(rawLocation, updateDelegate, locationPool) {
         const modelData = this.#debuggerModelToData.get(rawLocation.debuggerModel);
         if (!modelData) {
@@ -382,7 +386,7 @@ export class DebuggerWorkspaceBinding {
         }
         const modelData = this.#debuggerModelToData.get(target.model(SDK.DebuggerModel.DebuggerModel));
         if (modelData) {
-            modelData.translateRawFramesStep(rawFrames, translatedFrames);
+            await modelData.translateRawFramesStep(rawFrames, translatedFrames);
             return;
         }
         const frame = rawFrames.shift();
@@ -473,8 +477,8 @@ class ModelData {
         scope = scope || await this.#resourceMapping.functionBoundsAtRawLocation(rawLocation);
         return scope;
     }
-    translateRawFramesStep(rawFrames, translatedFrames) {
-        if (!this.compilerMapping.translateRawFramesStep(rawFrames, translatedFrames)) {
+    async translateRawFramesStep(rawFrames, translatedFrames) {
+        if (!await this.compilerMapping.translateRawFramesStep(rawFrames, translatedFrames)) {
             this.#defaultTranslateRawFramesStep(rawFrames, translatedFrames);
         }
     }

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

@@ -107,7 +107,7 @@ export class DeviceModeModel extends Common.ObjectWrapper.ObjectWrapper {
         this.#preferredSize = new Geometry.Size(1, 1);
         this.#initialized = false;
         this.#appliedDeviceSize = new Geometry.Size(1, 1);
-        this.#appliedDeviceScaleFactor = window.devicePixelRatio;
+        this.#appliedDeviceScaleFactor = globalThis.devicePixelRatio;
         this.#appliedUserAgentType = "Desktop" /* UA.DESKTOP */;
         this.#scaleSetting = Common.Settings.Settings.instance().createSetting('emulation.device-scale', 1);
         // We've used to allow zero before.

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

@@ -550,6 +550,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -569,6 +570,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -588,6 +590,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -607,6 +610,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -706,6 +710,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPad; CPU OS 18_5 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPad', 'mobile': true },
         'type': 'tablet',
     },
     {
@@ -725,6 +730,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPad', 'mobile': true },
         'type': 'tablet',
     },
     {
@@ -744,6 +750,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/18.5 Safari/605.1.15',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '18.5', 'architecture': '', 'model': 'iPad', 'mobile': true },
         'type': 'tablet',
     },
     {
@@ -982,6 +989,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 7_1_2 like Mac OS X) AppleWebKit/537.51.2 (KHTML, like Gecko) Version/7.0 Mobile/11D257 Safari/9537.53',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '7.1.2', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -1009,6 +1017,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_1 like Mac OS X) AppleWebKit/603.1.30 (KHTML, like Gecko) Version/10.0 Mobile/14E304 Safari/602.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '10.3.1', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -1036,6 +1045,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '13.2.3', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -1063,6 +1073,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '13.2.3', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -1076,6 +1087,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '13.2.3', 'architecture': '', 'model': 'iPhone', 'mobile': true },
         'type': 'phone',
     },
     {
@@ -1499,6 +1511,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '11.0', 'architecture': '', 'model': 'iPad', 'mobile': true },
         'type': 'tablet',
     },
     {
@@ -1512,6 +1525,7 @@ const emulatedDevices = [
         },
         'capabilities': ['touch', 'mobile'],
         'user-agent': 'Mozilla/5.0 (iPad; CPU OS 11_0 like Mac OS X) AppleWebKit/604.1.34 (KHTML, like Gecko) Version/11.0 Mobile/15A5341f Safari/604.1',
+        'user-agent-metadata': { 'platform': 'iOS', 'platformVersion': '11.0', 'architecture': '', 'model': 'iPad', 'mobile': true },
         'type': 'tablet',
     },
     {

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

@@ -6,13 +6,16 @@ let formatterWorkerPoolInstance;
 export class FormatterWorkerPool {
     taskQueue;
     workerTasks;
-    constructor() {
+    entrypointURL;
+    constructor(entrypointURL) {
         this.taskQueue = [];
         this.workerTasks = new Map();
+        this.entrypointURL =
+            entrypointURL ?? import.meta.resolve('../../entrypoints/formatter_worker/formatter_worker-entrypoint.js');
     }
-    static instance() {
-        if (!formatterWorkerPoolInstance) {
-            formatterWorkerPoolInstance = new FormatterWorkerPool();
+    static instance(opts) {
+        if (!formatterWorkerPoolInstance || opts?.forceNew) {
+            formatterWorkerPoolInstance = new FormatterWorkerPool(opts?.entrypointURL);
         }
         return formatterWorkerPoolInstance;
     }
@@ -31,7 +34,7 @@ export class FormatterWorkerPool {
         formatterWorkerPoolInstance = undefined;
     }
     createWorker() {
-        const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(new URL('../../entrypoints/formatter_worker/formatter_worker-entrypoint.js', import.meta.url).toString());
+        const worker = Platform.HostRuntime.HOST_RUNTIME.createWorker(this.entrypointURL);
         worker.onmessage = this.onWorkerMessage.bind(this, worker);
         worker.onerror = this.onWorkerError.bind(this, worker);
         return worker;

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

@@ -0,0 +1,33 @@
+// 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.
+import * as Common from '../../core/common/common.js';
+import * as Root from '../../core/root/root.js';
+let instance = null;
+export class Prototypes {
+    constructor() {
+    }
+    static instance() {
+        if (instance) {
+            return instance;
+        }
+        instance = new Prototypes();
+        return instance;
+    }
+    /**
+     * Returns true if the specific setting is turned on AND the GreenDev flag is enabled
+     */
+    isEnabled(setting) {
+        const greendevFlagEnabled = Boolean(Root.Runtime.hostConfig.devToolsGreenDevUi?.enabled);
+        return greendevFlagEnabled && this.settings()[setting].get();
+    }
+    settings() {
+        const settings = Common.Settings.Settings.instance();
+        const inDevToolsFloaty = settings.createSetting('greendev-in-devtools-floaty-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const inlineWidgets = settings.createSetting('greendev-inline-widgets-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const aiAnnotations = settings.createSetting('greendev-ai-annotations-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const artifactViewer = settings.createSetting('greendev-artifact-viewer-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        const copyToGemini = settings.createSetting('greendev-copy-to-gemini-enabled', false, "Local" /* Common.Settings.SettingStorageType.LOCAL */);
+        return { inDevToolsFloaty, inlineWidgets, aiAnnotations, artifactViewer, copyToGemini };
+    }
+}

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

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

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