chrome-ai-bridge 1.0.0

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

@@ -0,0 +1,260 @@
+// Copyright 2022 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 Platform from '../../../core/platform/platform.js';
+import * as CPUProfile from '../../cpu_profile/cpu_profile.js';
+import * as Helpers from '../helpers/helpers.js';
+import * as Types from '../types/types.js';
+let profilesInProcess = new Map();
+let entryToNode = new Map();
+// The profile head, containing its metadata like its start
+// time, comes in a "Profile" event. The sample data comes in
+// "ProfileChunk" events. We match these ProfileChunks with their head
+// using process and profile ids. However, in order to integrate sample
+// data with trace data, we need the thread id that owns each profile.
+// This thread id is extracted from the head event.
+// For this reason, we have a preprocessed data structure, where events
+// are matched by profile id, which we then finish processing to export
+// events matched by thread id.
+let preprocessedData = new Map();
+/**
+ * Profile source selection priority when multiple profiles exist for the same thread.
+ *
+ * Profile sources and their typical scenarios:
+ * - 'Internal': Browser-initiated profiling performance panel traces.
+ *   This is the profiling mechanism when users click "Record" in the Devtools UI.
+ * - 'Inspector': User-initiated via console.profile()/profileEnd() calls.
+ *   Represents explicit developer intent to profile specific code.
+ * - 'SelfProfiling': Page-initiated via JS Self-Profiling API.
+ *    Lower signal vs the two above; treated as fallback.
+ *
+ * Selection strategy:
+ * - CPU Profile mode: Prefer 'Inspector' (explicit user request).
+ * - Performance trace: Prefer 'Internal' (integrated timeline context), then 'Inspector'.
+ * - Sources not in the priority list (including 'SelfProfiling') act as fallbacks.
+ *   When no priority source matches, the first candidate profile is selected.
+ */
+const PROFILE_SOURCES_BY_PRIORITY = {
+    cpuProfile: ['Inspector'],
+    performanceTrace: ['Internal', 'Inspector'],
+};
+function parseCPUProfileData(parseOptions) {
+    const priorityList = parseOptions.isCPUProfile ? PROFILE_SOURCES_BY_PRIORITY.cpuProfile : PROFILE_SOURCES_BY_PRIORITY.performanceTrace;
+    for (const [processId, profiles] of preprocessedData) {
+        const profilesByThread = new Map();
+        for (const [profileId, preProcessedData] of profiles) {
+            const threadId = preProcessedData.threadId;
+            if (threadId === undefined) {
+                continue;
+            }
+            const listForThread = Platform.MapUtilities.getWithDefault(profilesByThread, threadId, () => []);
+            listForThread.push({ id: profileId, data: preProcessedData });
+        }
+        for (const [threadId, candidates] of profilesByThread) {
+            if (!candidates.length) {
+                continue;
+            }
+            let chosen = candidates[0];
+            for (const source of priorityList) {
+                const match = candidates.find(p => p.data.source === source);
+                if (match) {
+                    chosen = match;
+                    break;
+                }
+            }
+            const chosenData = chosen.data;
+            if (!chosenData.rawProfile.nodes.length) {
+                continue;
+            }
+            const indexStack = [];
+            const profileModel = new CPUProfile.CPUProfileDataModel.CPUProfileDataModel(chosenData.rawProfile);
+            const profileTree = Helpers.TreeHelpers.makeEmptyTraceEntryTree();
+            profileTree.maxDepth = profileModel.maxDepth;
+            const selectedProfileId = chosen.id;
+            const finalizedData = {
+                rawProfile: chosenData.rawProfile,
+                parsedProfile: profileModel,
+                profileCalls: [],
+                profileTree,
+                profileId: selectedProfileId,
+            };
+            const dataByThread = Platform.MapUtilities.getWithDefault(profilesInProcess, processId, () => new Map());
+            dataByThread.set(threadId, finalizedData);
+            // Only need to build pure JS ProfileCalls if we're parsing a CPU Profile, otherwise SamplesIntegrator does the work.
+            if (parseOptions.isCPUProfile) {
+                buildProfileCallsForCPUProfile();
+            }
+            function buildProfileCallsForCPUProfile() {
+                profileModel.forEachFrame(openFrameCallback, closeFrameCallback);
+                function openFrameCallback(depth, node, sampleIndex, timeStampMilliseconds) {
+                    if (threadId === undefined) {
+                        return;
+                    }
+                    const ts = Helpers.Timing.milliToMicro(Types.Timing.Milli(timeStampMilliseconds));
+                    const nodeId = node.id;
+                    const profileCall = Helpers.Trace.makeProfileCall(node, selectedProfileId, sampleIndex, ts, processId, threadId);
+                    finalizedData.profileCalls.push(profileCall);
+                    indexStack.push(finalizedData.profileCalls.length - 1);
+                    const traceEntryNode = Helpers.TreeHelpers.makeEmptyTraceEntryNode(profileCall, nodeId);
+                    entryToNode.set(profileCall, traceEntryNode);
+                    traceEntryNode.depth = depth;
+                    if (indexStack.length === 1) {
+                        // First call in the stack is a root call.
+                        finalizedData.profileTree?.roots.add(traceEntryNode);
+                    }
+                }
+                function closeFrameCallback(_depth, _node, _sampleIndex, _timeStampMillis, durMs, selfTimeMs) {
+                    const profileCallIndex = indexStack.pop();
+                    const profileCall = profileCallIndex !== undefined && finalizedData.profileCalls[profileCallIndex];
+                    if (!profileCall) {
+                        return;
+                    }
+                    const { callFrame, ts, pid, tid } = profileCall;
+                    const traceEntryNode = entryToNode.get(profileCall);
+                    if (callFrame === undefined || ts === undefined || pid === undefined || selectedProfileId === undefined ||
+                        tid === undefined || traceEntryNode === undefined) {
+                        return;
+                    }
+                    const dur = Helpers.Timing.milliToMicro(Types.Timing.Milli(durMs));
+                    const selfTime = Helpers.Timing.milliToMicro(Types.Timing.Milli(selfTimeMs));
+                    profileCall.dur = dur;
+                    traceEntryNode.selfTime = selfTime;
+                    const parentIndex = indexStack.at(-1);
+                    const parent = parentIndex !== undefined && finalizedData.profileCalls.at(parentIndex);
+                    const parentNode = parent && entryToNode.get(parent);
+                    if (!parentNode) {
+                        return;
+                    }
+                    traceEntryNode.parent = parentNode;
+                    parentNode.children.push(traceEntryNode);
+                }
+            }
+        }
+    }
+}
+export function reset() {
+    preprocessedData = new Map();
+    profilesInProcess = new Map();
+    entryToNode = new Map();
+}
+export function handleEvent(event) {
+    /**
+     * A fake trace event created to support CDP.Profiler.Profiles in the
+     * trace engine.
+     */
+    if (Types.Events.isSyntheticCpuProfile(event)) {
+        // At the moment we are attaching to a single node target so we
+        // should only get a single CPU profile. The values of the process
+        // id and thread id are not really important, so we use the data
+        // in the fake event. Should multi-thread CPU profiling be supported
+        // we could use these fields in the event to pass thread info.
+        const profileData = getOrCreatePreProcessedData(event.pid, event.id);
+        profileData.rawProfile = event.args.data.cpuProfile;
+        profileData.threadId = event.tid;
+        return;
+    }
+    if (Types.Events.isProfile(event)) {
+        // Do not use event.args.data.startTime as it is in CLOCK_MONOTONIC domain,
+        // but use profileEvent.ts which has been translated to Perfetto's clock
+        // domain. Also convert from ms to us.
+        // Note: events are collected on a different thread than what's sampled.
+        // The correct process and thread ids are specified by the profile.
+        const profileData = getOrCreatePreProcessedData(event.pid, event.id);
+        profileData.rawProfile.startTime = event.ts;
+        profileData.threadId = event.tid;
+        assignProfileSourceIfKnown(profileData, event.args?.data?.source);
+        return;
+    }
+    if (Types.Events.isProfileChunk(event)) {
+        const profileData = getOrCreatePreProcessedData(event.pid, event.id);
+        const cdpProfile = profileData.rawProfile;
+        const nodesAndSamples = event.args?.data?.cpuProfile || { samples: [] };
+        const samples = nodesAndSamples?.samples || [];
+        const traceIds = event.args?.data?.cpuProfile?.trace_ids;
+        for (const n of nodesAndSamples?.nodes || []) {
+            const lineNumber = typeof n.callFrame.lineNumber === 'undefined' ? -1 : n.callFrame.lineNumber;
+            const columnNumber = typeof n.callFrame.columnNumber === 'undefined' ? -1 : n.callFrame.columnNumber;
+            const scriptId = String(n.callFrame.scriptId);
+            const url = n.callFrame.url || '';
+            const node = {
+                ...n,
+                callFrame: {
+                    ...n.callFrame,
+                    url,
+                    lineNumber,
+                    columnNumber,
+                    scriptId,
+                },
+            };
+            cdpProfile.nodes.push(node);
+        }
+        const timeDeltas = event.args.data?.timeDeltas || [];
+        const lines = event.args.data?.lines || Array(samples.length).fill(0);
+        const columns = event.args.data?.columns || Array(samples.length).fill(0);
+        cdpProfile.samples?.push(...samples);
+        cdpProfile.timeDeltas?.push(...timeDeltas);
+        cdpProfile.lines?.push(...lines);
+        cdpProfile.columns?.push(...columns);
+        if (traceIds) {
+            cdpProfile.traceIds ??= {};
+            for (const key in traceIds) {
+                cdpProfile.traceIds[key] = traceIds[key];
+            }
+        }
+        if (cdpProfile.samples && cdpProfile.timeDeltas && cdpProfile.samples.length !== cdpProfile.timeDeltas.length) {
+            console.error('Failed to parse CPU profile.');
+            return;
+        }
+        if (!cdpProfile.endTime && cdpProfile.timeDeltas) {
+            const timeDeltas = cdpProfile.timeDeltas;
+            cdpProfile.endTime = timeDeltas.reduce((x, y) => x + y, cdpProfile.startTime);
+        }
+        assignProfileSourceIfKnown(profileData, event.args?.data?.source);
+        return;
+    }
+}
+export async function finalize(parseOptions = {}) {
+    parseCPUProfileData(parseOptions);
+}
+function assignProfileSourceIfKnown(profileData, source) {
+    if (Types.Events.VALID_PROFILE_SOURCES.includes(source)) {
+        profileData.source = source;
+    }
+}
+export function data() {
+    return {
+        profilesInProcess,
+        entryToNode,
+    };
+}
+function getOrCreatePreProcessedData(processId, profileId) {
+    const profileById = Platform.MapUtilities.getWithDefault(preprocessedData, processId, () => new Map());
+    return Platform.MapUtilities.getWithDefault(profileById, profileId, () => ({
+        rawProfile: {
+            startTime: 0,
+            endTime: 0,
+            nodes: [],
+            samples: [],
+            timeDeltas: [],
+            lines: [],
+            columns: [],
+        },
+        profileId,
+    }));
+}
+/**
+ * Returns the name of a function for a given synthetic profile call.
+ * We first look to find the ProfileNode representing this call, and use its
+ * function name. This is preferred (and should always exist) because if we
+ * resolve sourcemaps, we will update this name. If that name is not present,
+ * we fall back to the function name that was in the callframe that we got
+ * when parsing the profile's trace data.
+ */
+export function getProfileCallFunctionName(data, entry) {
+    const profile = data.profilesInProcess.get(entry.pid)?.get(entry.tid);
+    const node = profile?.parsedProfile.nodeById(entry.nodeId);
+    if (node?.functionName) {
+        return node.functionName;
+    }
+    return entry.callFrame.functionName;
+}

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

@@ -0,0 +1,97 @@
+// Copyright 2022 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 Helpers from '../helpers/helpers.js';
+import * as Types from '../types/types.js';
+// Each thread contains events. Events indicate the thread and process IDs, which are
+// used to store the event in the correct process thread entry below.
+let unpairedAsyncEvents = [];
+let legacyScreenshotEvents = [];
+let modernScreenshotEvents = [];
+let syntheticScreenshots = [];
+let frameSequenceToTs = {};
+export function reset() {
+    unpairedAsyncEvents = [];
+    legacyScreenshotEvents = [];
+    syntheticScreenshots = [];
+    modernScreenshotEvents = [];
+    frameSequenceToTs = {};
+}
+export function handleEvent(event) {
+    if (Types.Events.isLegacyScreenshot(event)) {
+        legacyScreenshotEvents.push(event);
+    }
+    else if (Types.Events.isScreenshot(event)) {
+        modernScreenshotEvents.push(event);
+    }
+    else if (Types.Events.isPipelineReporter(event)) {
+        unpairedAsyncEvents.push(event);
+    }
+}
+export async function finalize() {
+    const pipelineReporterEvents = Helpers.Trace.createMatchedSortedSyntheticEvents(unpairedAsyncEvents);
+    frameSequenceToTs = Object.fromEntries(pipelineReporterEvents.map(evt => {
+        const args = evt.args.data.beginEvent.args;
+        const frameReporter = 'frame_reporter' in args ? args.frame_reporter : args.chrome_frame_reporter;
+        const frameSequenceId = frameReporter.frame_sequence;
+        const presentationTs = Types.Timing.Micro(evt.ts + evt.dur);
+        return [frameSequenceId, presentationTs];
+    }));
+    for (const snapshotEvent of legacyScreenshotEvents) {
+        const { cat, name, ph, pid, tid } = snapshotEvent;
+        const syntheticEvent = Helpers.SyntheticEvents.SyntheticEventsManager.registerSyntheticEvent({
+            rawSourceEvent: snapshotEvent,
+            cat,
+            name,
+            ph,
+            pid,
+            tid,
+            // TODO(paulirish, crbug.com/41363012): investigate why getPresentationTimestamp(snapshotEvent) seems less accurate. Resolve screenshot timing inaccuracy.
+            // `getPresentationTimestamp(snapshotEvent) - snapshotEvent.ts` is how many microsec the screenshot should be adjusted to the right/later
+            ts: snapshotEvent.ts,
+            args: {
+                dataUri: `data:image/jpg;base64,${snapshotEvent.args.snapshot}`,
+            },
+        });
+        syntheticScreenshots.push(syntheticEvent);
+    }
+}
+export function screenshotImageDataUri(event) {
+    if (Types.Events.isLegacySyntheticScreenshot(event)) {
+        return event.args.dataUri;
+    }
+    return `data:image/jpg;base64,${event.args.snapshot}`;
+}
+/**
+ * Correct the screenshot timestamps
+ * The screenshot 'snapshot object' trace event has the "frame sequence number" attached as an ID.
+ * We match that up with the "PipelineReporter" trace events as they terminate at presentation.
+ * Presentation == when the pixels hit the screen. AKA Swap on the GPU
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function getPresentationTimestamp(screenshotEvent) {
+    const frameSequence = parseInt(screenshotEvent.id, 16);
+    // If it's 1, then it's an old trace (before https://crrev.com/c/4957973) and cannot be corrected.
+    if (frameSequence === 1) {
+        return screenshotEvent.ts;
+    }
+    // The screenshot trace event's `ts` reflects the "expected display time" which is ESTIMATE.
+    // It is set by the compositor frame sink from the `expected_display_time`, which is based on a previously known
+    // frame start PLUS the vsync interval (eg 16.6ms)
+    const updatedTs = frameSequenceToTs[frameSequence];
+    // Do we always find a match? No...
+    // We generally don't match the very first screenshot and, sometimes, the last
+    // The very first screenshot is requested immediately (even if nothing is painting). As a result there's no compositor
+    // instrumentation running alongside.
+    // The last one is sometimes missing as because the trace terminates right before the associated PipelineReporter is emitted.
+    return updatedTs ?? screenshotEvent.ts;
+}
+export function data() {
+    return {
+        legacySyntheticScreenshots: syntheticScreenshots.length ? syntheticScreenshots : null,
+        screenshots: modernScreenshotEvents.length ? modernScreenshotEvents : null,
+    };
+}
+export function deps() {
+    return ['Meta'];
+}

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

@@ -0,0 +1,276 @@
+// 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 Platform from '../../../core/platform/platform.js';
+import * as Types from '../types/types.js';
+import { data as metaHandlerData } from './MetaHandler.js';
+import { data as networkRequestsHandlerData } from './NetworkRequestsHandler.js';
+let scriptById = new Map();
+let frameIdByIsolate = new Map();
+export function deps() {
+    return ['Meta', 'NetworkRequests'];
+}
+export function reset() {
+    scriptById = new Map();
+    frameIdByIsolate = new Map();
+}
+export function handleEvent(event) {
+    const getOrMakeScript = (isolate, scriptIdAsNumber) => {
+        const scriptId = String(scriptIdAsNumber);
+        const key = `${isolate}.${scriptId}`;
+        return Platform.MapUtilities.getWithDefault(scriptById, key, () => ({ isolate, scriptId, frame: '', ts: event.ts }));
+    };
+    if (Types.Events.isRundownScriptCompiled(event) && event.args.data) {
+        const { isolate, scriptId, frame } = event.args.data;
+        const script = getOrMakeScript(isolate, scriptId);
+        script.frame = frame;
+        script.ts = event.ts;
+        return;
+    }
+    if (Types.Events.isRundownScript(event)) {
+        const { isolate, scriptId, url, sourceUrl, sourceMapUrl, sourceMapUrlElided } = event.args.data;
+        const script = getOrMakeScript(isolate, scriptId);
+        if (!script.frame) {
+            script.frame = frameIdByIsolate.get(String(isolate)) ?? '';
+        }
+        script.url = url;
+        script.ts = event.ts;
+        if (sourceUrl) {
+            script.sourceUrl = sourceUrl;
+        }
+        // Older traces may have data source map urls. Those can be very large, so a change
+        // was made to elide them from the trace.
+        // If elided, a fresh trace will fetch the source map from the Script model
+        // (see TimelinePanel getExistingSourceMap). If not fresh, the source map is resolved
+        // instead in this handler via `findCachedRawSourceMap`.
+        if (sourceMapUrlElided) {
+            script.sourceMapUrlElided = true;
+        }
+        else if (sourceMapUrl) {
+            script.sourceMapUrl = sourceMapUrl;
+        }
+        return;
+    }
+    if (Types.Events.isRundownScriptSource(event)) {
+        const { isolate, scriptId, sourceText } = event.args.data;
+        const script = getOrMakeScript(isolate, scriptId);
+        script.content = sourceText;
+        return;
+    }
+    if (Types.Events.isRundownScriptSourceLarge(event)) {
+        const { isolate, scriptId, sourceText } = event.args.data;
+        const script = getOrMakeScript(isolate, scriptId);
+        script.content = (script.content ?? '') + sourceText;
+        return;
+    }
+    // Setup frameIdByIsolate, which is used only in the case that we are missing
+    // rundown events for a script. We won't get a frame association from the rundown
+    // events if the recording started only after the script was first compiled. In
+    // that scenario, derive the frame via the isolate / FunctionCall events.
+    // TODO: ideally, we put the frame on ScriptCatchup event. So much easier. This approach has some
+    // issues.
+    if (Types.Events.isFunctionCall(event) && event.args.data?.isolate && event.args.data.frame) {
+        const { isolate, frame } = event.args.data;
+        const existingValue = frameIdByIsolate.get(isolate);
+        if (existingValue !== frame) {
+            frameIdByIsolate.set(isolate, frame);
+            // Update the scripts we discovered but without knowing their frame.
+            for (const script of scriptById.values()) {
+                if (!script.frame && script.isolate === isolate) {
+                    script.frame = frame;
+                }
+            }
+        }
+    }
+}
+function findFrame(meta, frameId) {
+    for (const frames of meta.frameByProcessId?.values()) {
+        const frame = frames.get(frameId);
+        if (frame) {
+            return frame;
+        }
+    }
+    return null;
+}
+function findNetworkRequest(networkRequests, script) {
+    if (!script.url) {
+        return null;
+    }
+    return networkRequests.find(request => request.args.data.url === script.url) ?? null;
+}
+function computeMappingEndColumns(map) {
+    const result = new Map();
+    const mappings = map.mappings();
+    for (let i = 0; i < mappings.length - 1; i++) {
+        const mapping = mappings[i];
+        const nextMapping = mappings[i + 1];
+        if (mapping.lineNumber === nextMapping.lineNumber) {
+            result.set(mapping, nextMapping.columnNumber);
+        }
+    }
+    // Now, all but the last mapping on each line will have a value in this map.
+    return result;
+}
+/**
+ * Using a script's contents and source map, attribute every generated byte to an authored source file.
+ */
+function computeGeneratedFileSizes(script) {
+    if (!script.sourceMap) {
+        throw new Error('expected source map');
+    }
+    const map = script.sourceMap;
+    const content = script.content ?? '';
+    const contentLength = content.length;
+    const lines = content.split('\n');
+    const files = {};
+    const totalBytes = contentLength;
+    let unmappedBytes = totalBytes;
+    const mappingEndCols = computeMappingEndColumns(script.sourceMap);
+    for (const mapping of map.mappings()) {
+        const source = mapping.sourceURL;
+        const lineNum = mapping.lineNumber;
+        const colNum = mapping.columnNumber;
+        const lastColNum = mappingEndCols.get(mapping);
+        // Webpack sometimes emits null mappings.
+        // https://github.com/mozilla/source-map/pull/303
+        if (!source) {
+            continue;
+        }
+        // Lines and columns are zero-based indices. Visually, lines are shown as a 1-based index.
+        const line = lines[lineNum];
+        if (line === null || line === undefined) {
+            const errorMessage = `${map.url()} mapping for line out of bounds: ${lineNum + 1}`;
+            return { errorMessage };
+        }
+        if (colNum > line.length) {
+            const errorMessage = `${map.url()} mapping for column out of bounds: ${lineNum + 1}:${colNum}`;
+            return { errorMessage };
+        }
+        let mappingLength = 0;
+        if (lastColNum !== undefined) {
+            if (lastColNum > line.length) {
+                const errorMessage = `${map.url()} mapping for last column out of bounds: ${lineNum + 1}:${lastColNum}`;
+                return { errorMessage };
+            }
+            mappingLength = lastColNum - colNum;
+        }
+        else {
+            // Add +1 to account for the newline.
+            mappingLength = line.length - colNum + 1;
+        }
+        files[source] = (files[source] || 0) + mappingLength;
+        unmappedBytes -= mappingLength;
+    }
+    return {
+        files,
+        unmappedBytes,
+        totalBytes,
+    };
+}
+export function getScriptGeneratedSizes(script) {
+    if (script.sourceMap && !script.sizes) {
+        script.sizes = computeGeneratedFileSizes(script);
+    }
+    return script.sizes ?? null;
+}
+function findCachedRawSourceMap(script, options) {
+    if (options.isFreshRecording || !options.metadata?.sourceMaps) {
+        // Exit if this is not a loaded trace w/ source maps in the metadata.
+        return;
+    }
+    // For elided data url source maps, search the metadata source maps by script url.
+    if (script.sourceMapUrlElided) {
+        if (!script.url) {
+            return;
+        }
+        const cachedSourceMap = options.metadata.sourceMaps.find(m => m.url === script.url);
+        if (cachedSourceMap) {
+            return cachedSourceMap.sourceMap;
+        }
+        return;
+    }
+    if (!script.sourceMapUrl) {
+        return;
+    }
+    // Otherwise, search by source map url.
+    // Note: early enhanced traces may have this field set for data urls. Ignore those,
+    // as they were never stored in metadata sourcemap.
+    const isDataUrl = script.sourceMapUrl.startsWith('data:');
+    if (!isDataUrl) {
+        const cachedSourceMap = options.metadata.sourceMaps.find(m => m.sourceMapUrl === script.sourceMapUrl);
+        if (cachedSourceMap) {
+            return cachedSourceMap.sourceMap;
+        }
+    }
+    return;
+}
+export async function finalize(options) {
+    const meta = metaHandlerData();
+    const networkRequests = [...networkRequestsHandlerData().byId.values()];
+    const documentUrls = new Set();
+    for (const frames of meta.frameByProcessId.values()) {
+        for (const frame of frames.values()) {
+            documentUrls.add(frame.url);
+        }
+    }
+    for (const script of scriptById.values()) {
+        script.request = findNetworkRequest(networkRequests, script) ?? undefined;
+        script.inline = !!script.url && documentUrls.has(script.url);
+    }
+    if (!options.resolveSourceMap) {
+        return;
+    }
+    const promises = [];
+    for (const script of scriptById.values()) {
+        // No frame or url means the script came from somewhere we don't care about.
+        // Note: scripts from inline <SCRIPT> elements use the url of the HTML document,
+        // so aren't ignored.
+        if (!script.frame || !script.url || (!script.sourceMapUrl && !script.sourceMapUrlElided)) {
+            continue;
+        }
+        const frameUrl = findFrame(meta, script.frame)?.url;
+        if (!frameUrl) {
+            continue;
+        }
+        // If there is a `sourceURL` magic comment, resolve the compiledUrl against the frame url.
+        // example: `// #sourceURL=foo.js` for target frame https://www.example.com/home -> https://www.example.com/home/foo.js
+        let sourceUrl = script.url;
+        if (script.sourceUrl) {
+            sourceUrl = Common.ParsedURL.ParsedURL.completeURL(frameUrl, script.sourceUrl) ?? script.sourceUrl;
+        }
+        let sourceMapUrl;
+        if (script.sourceMapUrl) {
+            // Resolve the source map url. The value given by v8 may be relative, so resolve it here.
+            // This process should match the one in `SourceMapManager.attachSourceMap`.
+            sourceMapUrl =
+                Common.ParsedURL.ParsedURL.completeURL(sourceUrl, script.sourceMapUrl);
+            if (!sourceMapUrl) {
+                continue;
+            }
+            script.sourceMapUrl = sourceMapUrl;
+        }
+        const params = {
+            scriptId: script.scriptId,
+            scriptUrl: script.url,
+            sourceUrl: sourceUrl,
+            sourceMapUrl: sourceMapUrl ?? '',
+            frame: script.frame,
+            cachedRawSourceMap: findCachedRawSourceMap(script, options),
+        };
+        const promise = options.resolveSourceMap(params).then(sourceMap => {
+            if (sourceMap) {
+                script.sourceMap = sourceMap;
+            }
+        });
+        promises.push(promise.catch(e => {
+            console.error('Uncaught error when resolving source map', params, e);
+        }));
+    }
+    await Promise.all(promises);
+}
+export function data() {
+    return {
+        scripts: [...scriptById.values()],
+    };
+}