chrome-devtools-mcp 0.10.1 → 0.10.2

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

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 import * as Common from '../../core/common/common.js';
 import * as Platform from '../../core/platform/platform.js';
+import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 // eslint-disable-next-line @devtools/es-modules-import
 import * as StackTraceImpl from '../stack_trace/stack_trace_impl.js';
@@ -13,19 +14,23 @@ import { DefaultScriptMapping } from './DefaultScriptMapping.js';
 import { LiveLocationWithPool } from './LiveLocation.js';
 import { NetworkProject } from './NetworkProject.js';
 import { ResourceScriptMapping } from './ResourceScriptMapping.js';
-let debuggerWorkspaceBindingInstance;
 export class DebuggerWorkspaceBinding {
     resourceMapping;
     #debuggerModelToData;
     #liveLocationPromises;
     pluginManager;
-    constructor(resourceMapping, targetManager, ignoreListManager) {
+    ignoreListManager;
+    workspace;
+    constructor(resourceMapping, targetManager, ignoreListManager, workspace) {
         this.resourceMapping = resourceMapping;
+        this.resourceMapping.debuggerWorkspaceBinding = this;
+        this.ignoreListManager = ignoreListManager;
+        this.workspace = workspace;
         this.#debuggerModelToData = new Map();
         targetManager.addModelListener(SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this);
         targetManager.addModelListener(SDK.DebuggerModel.DebuggerModel, SDK.DebuggerModel.Events.DebuggerResumed, this.debuggerResumed, this);
         targetManager.observeModels(SDK.DebuggerModel.DebuggerModel, this);
-        ignoreListManager.addEventListener("IGNORED_SCRIPT_RANGES_UPDATED" /* Workspace.IgnoreListManager.Events.IGNORED_SCRIPT_RANGES_UPDATED */, event => this.updateLocations(event.data));
+        this.ignoreListManager.addEventListener("IGNORED_SCRIPT_RANGES_UPDATED" /* Workspace.IgnoreListManager.Events.IGNORED_SCRIPT_RANGES_UPDATED */, event => this.updateLocations(event.data));
         this.#liveLocationPromises = new Set();
         this.pluginManager = new DebuggerLanguagePluginManager(targetManager, resourceMapping.workspace, this);
     }
@@ -34,19 +39,18 @@ export class DebuggerWorkspaceBinding {
             modelData.compilerMapping.setFunctionRanges(uiSourceCode, ranges);
         }
     }
-    static instance(opts = { forceNew: null, resourceMapping: null, targetManager: null, ignoreListManager: null }) {
-        const { forceNew, resourceMapping, targetManager, ignoreListManager } = opts;
-        if (!debuggerWorkspaceBindingInstance || forceNew) {
-            if (!resourceMapping || !targetManager || !ignoreListManager) {
+    static instance(opts = { forceNew: null, resourceMapping: null, targetManager: null, ignoreListManager: null, workspace: null }) {
+        const { forceNew, resourceMapping, targetManager, ignoreListManager, workspace } = opts;
+        if (forceNew) {
+            if (!resourceMapping || !targetManager || !ignoreListManager || !workspace) {
                 throw new Error(`Unable to create DebuggerWorkspaceBinding: resourceMapping, targetManager and IgnoreLIstManager must be provided: ${new Error().stack}`);
             }
-            debuggerWorkspaceBindingInstance =
-                new DebuggerWorkspaceBinding(resourceMapping, targetManager, ignoreListManager);
+            Root.DevToolsContext.globalInstance().set(DebuggerWorkspaceBinding, new DebuggerWorkspaceBinding(resourceMapping, targetManager, ignoreListManager, workspace));
         }
-        return debuggerWorkspaceBindingInstance;
+        return Root.DevToolsContext.globalInstance().get(DebuggerWorkspaceBinding);
     }
     static removeInstance() {
-        debuggerWorkspaceBindingInstance = undefined;
+        Root.DevToolsContext.globalInstance().delete(DebuggerWorkspaceBinding);
     }
     async computeAutoStepRanges(mode, callFrame) {
         function contained(location, range) {
@@ -199,11 +203,10 @@ export class DebuggerWorkspaceBinding {
     }
     waitForUISourceCodeAdded(url, target) {
         return new Promise(resolve => {
-            const workspace = Workspace.Workspace.WorkspaceImpl.instance();
-            const descriptor = workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, event => {
+            const descriptor = this.workspace.addEventListener(Workspace.Workspace.Events.UISourceCodeAdded, event => {
                 const uiSourceCode = event.data;
                 if (uiSourceCode.url() === url && NetworkProject.targetForUISourceCode(uiSourceCode) === target) {
-                    workspace.removeEventListener(Workspace.Workspace.Events.UISourceCodeAdded, descriptor.listener);
+                    this.workspace.removeEventListener(Workspace.Workspace.Events.UISourceCodeAdded, descriptor.listener);
                     resolve(uiSourceCode);
                 }
             });

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

@@ -6,8 +6,6 @@ import * as SDK from '../../core/sdk/sdk.js';
 import * as TextUtils from '../text_utils/text_utils.js';
 import * as Workspace from '../workspace/workspace.js';
 import { ContentProviderBasedProject } from './ContentProviderBasedProject.js';
-import { CSSWorkspaceBinding } from './CSSWorkspaceBinding.js';
-import { DebuggerWorkspaceBinding } from './DebuggerWorkspaceBinding.js';
 import { NetworkProject } from './NetworkProject.js';
 import { resourceMetadata } from './ResourceUtils.js';
 const styleSheetRangeMap = new WeakMap();
@@ -22,12 +20,40 @@ function computeStyleSheetRange(header) {
 export class ResourceMapping {
     workspace;
     #modelToInfo = new Map();
+    #debuggerWorkspaceBinding = null;
+    #cssWorkspaceBinding = null;
     constructor(targetManager, workspace) {
         this.workspace = workspace;
         targetManager.observeModels(SDK.ResourceTreeModel.ResourceTreeModel, this);
     }
+    get debuggerWorkspaceBinding() {
+        // TODO(crbug.com/458180550): Throw when this.#debuggerWorkspaceBinding is null and never return null.
+        //                            The only reason we don't throw and return an instance unconditionally
+        //                            is that unit tests often don't set-up both the *WorkspaceBindings.
+        return this.#debuggerWorkspaceBinding;
+    }
+    /* {@link DebuggerWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */
+    set debuggerWorkspaceBinding(debuggerWorkspaceBinding) {
+        if (this.#debuggerWorkspaceBinding) {
+            throw new Error('DebuggerWorkspaceBinding already set');
+        }
+        this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    }
+    get cssWorkspaceBinding() {
+        // TODO(crbug.com/458180550): Throw when this.#cssWorkspaceBinding is null and never return null.
+        //                            The only reason we don't throw and return an instance unconditionally
+        //                            is that unit tests often don't set-up both the *WorkspaceBindings.
+        return this.#cssWorkspaceBinding;
+    }
+    /* {@link CSSWorkspaceBinding} and ResourceMapping form a cycle so we can't wire it up at ctor time. */
+    set cssWorkspaceBinding(cssWorkspaceBinding) {
+        if (this.#cssWorkspaceBinding) {
+            throw new Error('CSSWorkspaceBinding already set');
+        }
+        this.#cssWorkspaceBinding = cssWorkspaceBinding;
+    }
     modelAdded(resourceTreeModel) {
-        const info = new ModelInfo(this.workspace, resourceTreeModel);
+        const info = new ModelInfo(this, resourceTreeModel);
         this.#modelToInfo.set(resourceTreeModel, info);
     }
     modelRemoved(resourceTreeModel) {
@@ -225,9 +251,11 @@ class ModelInfo {
     #bindings = new Map();
     #cssModel;
     #eventListeners;
-    constructor(workspace, resourceTreeModel) {
+    resourceMapping;
+    constructor(resourceMapping, resourceTreeModel) {
         const target = resourceTreeModel.target();
-        this.project = new ContentProviderBasedProject(workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
+        this.resourceMapping = resourceMapping;
+        this.project = new ContentProviderBasedProject(resourceMapping.workspace, 'resources:' + target.id(), Workspace.Workspace.projectTypes.Network, '', false /* isServiceProject */);
         NetworkProject.setTargetForProject(this.project, target);
         const cssModel = target.model(SDK.CSSModel.CSSModel);
         console.assert(Boolean(cssModel));
@@ -293,7 +321,7 @@ class ModelInfo {
         }
         let binding = this.#bindings.get(resource.url);
         if (!binding) {
-            binding = new Binding(this.project, resource);
+            binding = new Binding(this, resource);
             this.#bindings.set(resource.url, binding);
         }
         else {
@@ -347,9 +375,13 @@ class Binding {
     #project;
     #uiSourceCode;
     #edits = [];
-    constructor(project, resource) {
+    #debuggerWorkspaceBinding;
+    #cssWorkspaceBinding;
+    constructor(modelInfo, resource) {
         this.resources = new Set([resource]);
-        this.#project = project;
+        this.#project = modelInfo.project;
+        this.#debuggerWorkspaceBinding = modelInfo.resourceMapping.debuggerWorkspaceBinding;
+        this.#cssWorkspaceBinding = modelInfo.resourceMapping.cssWorkspaceBinding;
         this.#uiSourceCode = this.#project.createUISourceCode(resource.url, resource.contentType());
         boundUISourceCodes.add(this.#uiSourceCode);
         if (resource.frameId) {
@@ -357,8 +389,8 @@ class Binding {
         }
         this.#project.addUISourceCodeWithProvider(this.#uiSourceCode, this, resourceMetadata(resource), resource.mimeType);
         void Promise.all([
-            ...this.inlineScripts().map(script => DebuggerWorkspaceBinding.instance().updateLocations(script)),
-            ...this.inlineStyles().map(style => CSSWorkspaceBinding.instance().updateLocations(style)),
+            ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)),
+            ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)),
         ]);
     }
     inlineStyles() {
@@ -421,7 +453,7 @@ class Binding {
                     continue;
                 }
                 scriptRangeMap.set(script, range.rebaseAfterTextEdit(oldRange, newRange));
-                updatePromises.push(DebuggerWorkspaceBinding.instance().updateLocations(script));
+                updatePromises.push(this.#debuggerWorkspaceBinding?.updateLocations(script));
             }
             for (const style of styles) {
                 const range = styleSheetRangeMap.get(style) ?? computeStyleSheetRange(style);
@@ -429,7 +461,7 @@ class Binding {
                     continue;
                 }
                 styleSheetRangeMap.set(style, range.rebaseAfterTextEdit(oldRange, newRange));
-                updatePromises.push(CSSWorkspaceBinding.instance().updateLocations(style));
+                updatePromises.push(this.#cssWorkspaceBinding?.updateLocations(style));
             }
             await Promise.all(updatePromises);
         }
@@ -450,8 +482,8 @@ class Binding {
     dispose() {
         this.#project.removeUISourceCode(this.#uiSourceCode.url());
         void Promise.all([
-            ...this.inlineScripts().map(script => DebuggerWorkspaceBinding.instance().updateLocations(script)),
-            ...this.inlineStyles().map(style => CSSWorkspaceBinding.instance().updateLocations(style)),
+            ...this.inlineScripts().map(script => this.#debuggerWorkspaceBinding?.updateLocations(script)),
+            ...this.inlineStyles().map(style => this.#cssWorkspaceBinding?.updateLocations(style)),
         ]);
     }
     firstResource() {

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

@@ -0,0 +1,202 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+import { Issue } from './Issue.js';
+function getIssueCode(details) {
+    switch (details.violationType) {
+        case "PermissionPolicyDisabled" /* Protocol.Audits.AttributionReportingIssueType.PermissionPolicyDisabled */:
+            return "AttributionReportingIssue::PermissionPolicyDisabled" /* IssueCode.PERMISSION_POLICY_DISABLED */;
+        case "UntrustworthyReportingOrigin" /* Protocol.Audits.AttributionReportingIssueType.UntrustworthyReportingOrigin */:
+            return "AttributionReportingIssue::UntrustworthyReportingOrigin" /* IssueCode.UNTRUSTWORTHY_REPORTING_ORIGIN */;
+        case "InsecureContext" /* Protocol.Audits.AttributionReportingIssueType.InsecureContext */:
+            return "AttributionReportingIssue::InsecureContext" /* IssueCode.INSECURE_CONTEXT */;
+        case "InvalidHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidHeader */:
+            return "AttributionReportingIssue::InvalidRegisterSourceHeader" /* IssueCode.INVALID_REGISTER_SOURCE_HEADER */;
+        case "InvalidRegisterTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterTriggerHeader */:
+            return "AttributionReportingIssue::InvalidRegisterTriggerHeader" /* IssueCode.INVALID_REGISTER_TRIGGER_HEADER */;
+        case "SourceAndTriggerHeaders" /* Protocol.Audits.AttributionReportingIssueType.SourceAndTriggerHeaders */:
+            return "AttributionReportingIssue::SourceAndTriggerHeaders" /* IssueCode.SOURCE_AND_TRIGGER_HEADERS */;
+        case "SourceIgnored" /* Protocol.Audits.AttributionReportingIssueType.SourceIgnored */:
+            return "AttributionReportingIssue::SourceIgnored" /* IssueCode.SOURCE_IGNORED */;
+        case "TriggerIgnored" /* Protocol.Audits.AttributionReportingIssueType.TriggerIgnored */:
+            return "AttributionReportingIssue::TriggerIgnored" /* IssueCode.TRIGGER_IGNORED */;
+        case "OsSourceIgnored" /* Protocol.Audits.AttributionReportingIssueType.OsSourceIgnored */:
+            return "AttributionReportingIssue::OsSourceIgnored" /* IssueCode.OS_SOURCE_IGNORED */;
+        case "OsTriggerIgnored" /* Protocol.Audits.AttributionReportingIssueType.OsTriggerIgnored */:
+            return "AttributionReportingIssue::OsTriggerIgnored" /* IssueCode.OS_TRIGGER_IGNORED */;
+        case "InvalidRegisterOsSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterOsSourceHeader */:
+            return "AttributionReportingIssue::InvalidRegisterOsSourceHeader" /* IssueCode.INVALID_REGISTER_OS_SOURCE_HEADER */;
+        case "InvalidRegisterOsTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidRegisterOsTriggerHeader */:
+            return "AttributionReportingIssue::InvalidRegisterOsTriggerHeader" /* IssueCode.INVALID_REGISTER_OS_TRIGGER_HEADER */;
+        case "WebAndOsHeaders" /* Protocol.Audits.AttributionReportingIssueType.WebAndOsHeaders */:
+            return "AttributionReportingIssue::WebAndOsHeaders" /* IssueCode.WEB_AND_OS_HEADERS */;
+        case "NoWebOrOsSupport" /* Protocol.Audits.AttributionReportingIssueType.NoWebOrOsSupport */:
+            return "AttributionReportingIssue::NoWebOrOsSupport" /* IssueCode.NO_WEB_OR_OS_SUPPORT */;
+        case "NavigationRegistrationWithoutTransientUserActivation" /* Protocol.Audits.AttributionReportingIssueType.NavigationRegistrationWithoutTransientUserActivation */:
+            return "AttributionReportingIssue::NavigationRegistrationWithoutTransientUserActivation" /* IssueCode.NAVIGATION_REGISTRATION_WITHOUT_TRANSIENT_USER_ACTIVATION */;
+        case "InvalidInfoHeader" /* Protocol.Audits.AttributionReportingIssueType.InvalidInfoHeader */:
+            return "AttributionReportingIssue::InvalidInfoHeader" /* IssueCode.INVALID_INFO_HEADER */;
+        case "NoRegisterSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterSourceHeader */:
+            return "AttributionReportingIssue::NoRegisterSourceHeader" /* IssueCode.NO_REGISTER_SOURCE_HEADER */;
+        case "NoRegisterTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterTriggerHeader */:
+            return "AttributionReportingIssue::NoRegisterTriggerHeader" /* IssueCode.NO_REGISTER_TRIGGER_HEADER */;
+        case "NoRegisterOsSourceHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterOsSourceHeader */:
+            return "AttributionReportingIssue::NoRegisterOsSourceHeader" /* IssueCode.NO_REGISTER_OS_SOURCE_HEADER */;
+        case "NoRegisterOsTriggerHeader" /* Protocol.Audits.AttributionReportingIssueType.NoRegisterOsTriggerHeader */:
+            return "AttributionReportingIssue::NoRegisterOsTriggerHeader" /* IssueCode.NO_REGISTER_OS_TRIGGER_HEADER */;
+        case "NavigationRegistrationUniqueScopeAlreadySet" /* Protocol.Audits.AttributionReportingIssueType.NavigationRegistrationUniqueScopeAlreadySet */:
+            return "AttributionReportingIssue::NavigationRegistrationUniqueScopeAlreadySet" /* IssueCode.NAVIGATION_REGISTRATION_UNIQUE_SCOPE_ALREADY_SET */;
+        default:
+            return "AttributionReportingIssue::Unknown" /* IssueCode.UNKNOWN */;
+    }
+}
+const structuredHeaderLink = {
+    link: 'https://tools.ietf.org/id/draft-ietf-httpbis-header-structure-15.html#rfc.section.4.2.2',
+    linkTitle: 'Structured Headers RFC',
+};
+export class AttributionReportingIssue extends Issue {
+    issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super(getIssueCode(issueDetails), issuesModel);
+        this.issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "AttributionReporting" /* IssueCategory.ATTRIBUTION_REPORTING */;
+    }
+    getHeaderValidatorLink(name) {
+        const url = new URL('https://wicg.github.io/attribution-reporting-api/validate-headers');
+        url.searchParams.set('header', name);
+        if (this.issueDetails.invalidParameter) {
+            url.searchParams.set('json', this.issueDetails.invalidParameter);
+        }
+        return {
+            link: url.toString(),
+            linkTitle: 'Header Validator',
+        };
+    }
+    getDescription() {
+        switch (this.code()) {
+            case "AttributionReportingIssue::PermissionPolicyDisabled" /* IssueCode.PERMISSION_POLICY_DISABLED */:
+                return {
+                    file: 'arPermissionPolicyDisabled.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::UntrustworthyReportingOrigin" /* IssueCode.UNTRUSTWORTHY_REPORTING_ORIGIN */:
+                return {
+                    file: 'arUntrustworthyReportingOrigin.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InsecureContext" /* IssueCode.INSECURE_CONTEXT */:
+                return {
+                    file: 'arInsecureContext.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InvalidRegisterSourceHeader" /* IssueCode.INVALID_REGISTER_SOURCE_HEADER */:
+                return {
+                    file: 'arInvalidRegisterSourceHeader.md',
+                    links: [this.getHeaderValidatorLink('source')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterTriggerHeader" /* IssueCode.INVALID_REGISTER_TRIGGER_HEADER */:
+                return {
+                    file: 'arInvalidRegisterTriggerHeader.md',
+                    links: [this.getHeaderValidatorLink('trigger')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterOsSourceHeader" /* IssueCode.INVALID_REGISTER_OS_SOURCE_HEADER */:
+                return {
+                    file: 'arInvalidRegisterOsSourceHeader.md',
+                    links: [this.getHeaderValidatorLink('os-source')],
+                };
+            case "AttributionReportingIssue::InvalidRegisterOsTriggerHeader" /* IssueCode.INVALID_REGISTER_OS_TRIGGER_HEADER */:
+                return {
+                    file: 'arInvalidRegisterOsTriggerHeader.md',
+                    links: [this.getHeaderValidatorLink('os-trigger')],
+                };
+            case "AttributionReportingIssue::SourceAndTriggerHeaders" /* IssueCode.SOURCE_AND_TRIGGER_HEADERS */:
+                return {
+                    file: 'arSourceAndTriggerHeaders.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::WebAndOsHeaders" /* IssueCode.WEB_AND_OS_HEADERS */:
+                return {
+                    file: 'arWebAndOsHeaders.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::SourceIgnored" /* IssueCode.SOURCE_IGNORED */:
+                return {
+                    file: 'arSourceIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::TriggerIgnored" /* IssueCode.TRIGGER_IGNORED */:
+                return {
+                    file: 'arTriggerIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::OsSourceIgnored" /* IssueCode.OS_SOURCE_IGNORED */:
+                return {
+                    file: 'arOsSourceIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::OsTriggerIgnored" /* IssueCode.OS_TRIGGER_IGNORED */:
+                return {
+                    file: 'arOsTriggerIgnored.md',
+                    links: [structuredHeaderLink],
+                };
+            case "AttributionReportingIssue::NavigationRegistrationWithoutTransientUserActivation" /* IssueCode.NAVIGATION_REGISTRATION_WITHOUT_TRANSIENT_USER_ACTIVATION */:
+                return {
+                    file: 'arNavigationRegistrationWithoutTransientUserActivation.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoWebOrOsSupport" /* IssueCode.NO_WEB_OR_OS_SUPPORT */:
+                return {
+                    file: 'arNoWebOrOsSupport.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::InvalidInfoHeader" /* IssueCode.INVALID_INFO_HEADER */:
+                return {
+                    file: 'arInvalidInfoHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterSourceHeader" /* IssueCode.NO_REGISTER_SOURCE_HEADER */:
+                return {
+                    file: 'arNoRegisterSourceHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterTriggerHeader" /* IssueCode.NO_REGISTER_TRIGGER_HEADER */:
+                return {
+                    file: 'arNoRegisterTriggerHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterOsSourceHeader" /* IssueCode.NO_REGISTER_OS_SOURCE_HEADER */:
+                return {
+                    file: 'arNoRegisterOsSourceHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NoRegisterOsTriggerHeader" /* IssueCode.NO_REGISTER_OS_TRIGGER_HEADER */:
+                return {
+                    file: 'arNoRegisterOsTriggerHeader.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::NavigationRegistrationUniqueScopeAlreadySet" /* IssueCode.NAVIGATION_REGISTRATION_UNIQUE_SCOPE_ALREADY_SET */:
+                return {
+                    file: 'arNavigationRegistrationUniqueScopeAlreadySet.md',
+                    links: [],
+                };
+            case "AttributionReportingIssue::Unknown" /* IssueCode.UNKNOWN */:
+                return null;
+        }
+    }
+    primaryKey() {
+        return JSON.stringify(this.issueDetails);
+    }
+    getKind() {
+        return "PageError" /* IssueKind.PAGE_ERROR */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const { attributionReportingIssueDetails } = inspectorIssue.details;
+        if (!attributionReportingIssueDetails) {
+            console.warn('Attribution Reporting issue without details received.');
+            return [];
+        }
+        return [new AttributionReportingIssue(attributionReportingIssueDetails, issuesModel)];
+    }
+}

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

@@ -0,0 +1,57 @@
+// Copyright 2023 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+const UIStrings = {
+    /**
+     * @description Title for Bounce Tracking Mitigation explainer url link.
+     */
+    bounceTrackingMitigations: 'Bounce tracking mitigations',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/BounceTrackingIssue.ts', UIStrings);
+const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
+export class BounceTrackingIssue extends Issue {
+    #issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super("BounceTrackingIssue" /* Protocol.Audits.InspectorIssueCode.BounceTrackingIssue */, issuesModel);
+        this.#issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    getDescription() {
+        return {
+            file: 'bounceTrackingMitigations.md',
+            links: [
+                {
+                    link: 'https://privacycg.github.io/nav-tracking-mitigations/#bounce-tracking-mitigations',
+                    linkTitle: i18nString(UIStrings.bounceTrackingMitigations),
+                },
+            ],
+        };
+    }
+    details() {
+        return this.#issueDetails;
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    primaryKey() {
+        return JSON.stringify(this.#issueDetails);
+    }
+    trackingSites() {
+        if (this.#issueDetails.trackingSites) {
+            return this.#issueDetails.trackingSites;
+        }
+        return [];
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.bounceTrackingIssueDetails;
+        if (!details) {
+            console.warn('Bounce tracking issue without details received.');
+            return [];
+        }
+        return [new BounceTrackingIssue(details, issuesModel)];
+    }
+}

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

@@ -0,0 +1,31 @@
+import * as SDK from '../../core/sdk/sdk.js';
+/**
+ * Responsible for asking autofill for current form issues. This currently happens when devtools is first open.
+ */
+// TODO(crbug.com/1399414): Trigger check form issues when an element with an associated issue is editted in the issues panel.
+let checkFormsIssuesTriggerInstance = null;
+export class CheckFormsIssuesTrigger {
+    constructor() {
+        SDK.TargetManager.TargetManager.instance().addModelListener(SDK.ResourceTreeModel.ResourceTreeModel, SDK.ResourceTreeModel.Events.Load, this.#pageLoaded, this, { scoped: true });
+        for (const model of SDK.TargetManager.TargetManager.instance().models(SDK.ResourceTreeModel.ResourceTreeModel)) {
+            if (model.target().outermostTarget() !== model.target()) {
+                continue;
+            }
+            this.#checkFormsIssues(model);
+        }
+    }
+    static instance({ forceNew } = { forceNew: false }) {
+        if (!checkFormsIssuesTriggerInstance || forceNew) {
+            checkFormsIssuesTriggerInstance = new CheckFormsIssuesTrigger();
+        }
+        return checkFormsIssuesTriggerInstance;
+    }
+    // TODO(crbug.com/1399414): Handle response by dropping current issues in favor of new ones.
+    #checkFormsIssues(resourceTreeModel) {
+        void resourceTreeModel.target().auditsAgent().invoke_checkFormsIssues();
+    }
+    #pageLoaded(event) {
+        const { resourceTreeModel } = event.data;
+        this.#checkFormsIssues(resourceTreeModel);
+    }
+}

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

@@ -0,0 +1,76 @@
+// Copyright 2021 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 i18n from '../../core/i18n/i18n.js';
+import { Issue } from './Issue.js';
+import { resolveLazyDescription, } from './MarkdownIssueDescription.js';
+const UIStrings = {
+    /**
+     * @description Title for Client Hint specification url link
+     */
+    clientHintsInfrastructure: 'Client Hints Infrastructure',
+};
+const str_ = i18n.i18n.registerUIStrings('models/issues_manager/ClientHintIssue.ts', UIStrings);
+const i18nLazyString = i18n.i18n.getLazilyComputedLocalizedString.bind(undefined, str_);
+export class ClientHintIssue extends Issue {
+    issueDetails;
+    constructor(issueDetails, issuesModel) {
+        super({
+            code: "ClientHintIssue" /* Protocol.Audits.InspectorIssueCode.ClientHintIssue */,
+            umaCode: ["ClientHintIssue" /* Protocol.Audits.InspectorIssueCode.ClientHintIssue */, issueDetails.clientHintIssueReason].join('::'),
+        }, issuesModel);
+        this.issueDetails = issueDetails;
+    }
+    getCategory() {
+        return "Other" /* IssueCategory.OTHER */;
+    }
+    details() {
+        return this.issueDetails;
+    }
+    getDescription() {
+        const description = issueDescriptions.get(this.issueDetails.clientHintIssueReason);
+        if (!description) {
+            return null;
+        }
+        return resolveLazyDescription(description);
+    }
+    sources() {
+        return [this.issueDetails.sourceCodeLocation];
+    }
+    primaryKey() {
+        return JSON.stringify(this.issueDetails);
+    }
+    getKind() {
+        return "BreakingChange" /* IssueKind.BREAKING_CHANGE */;
+    }
+    static fromInspectorIssue(issuesModel, inspectorIssue) {
+        const details = inspectorIssue.details.clientHintIssueDetails;
+        if (!details) {
+            console.warn('Client Hint issue without details received.');
+            return [];
+        }
+        return [new ClientHintIssue(details, issuesModel)];
+    }
+}
+const issueDescriptions = new Map([
+    [
+        "MetaTagAllowListInvalidOrigin" /* Protocol.Audits.ClientHintIssueReason.MetaTagAllowListInvalidOrigin */,
+        {
+            file: 'clientHintMetaTagAllowListInvalidOrigin.md',
+            links: [{
+                    link: 'https://wicg.github.io/client-hints-infrastructure/',
+                    linkTitle: i18nLazyString(UIStrings.clientHintsInfrastructure),
+                }],
+        },
+    ],
+    [
+        "MetaTagModifiedHTML" /* Protocol.Audits.ClientHintIssueReason.MetaTagModifiedHTML */,
+        {
+            file: 'clientHintMetaTagModifiedHTML.md',
+            links: [{
+                    link: 'https://wicg.github.io/client-hints-infrastructure/',
+                    linkTitle: i18nLazyString(UIStrings.clientHintsInfrastructure),
+                }],
+        },
+    ],
+]);